1 /* Coding system handler (conversion, detection, etc).
2 Copyright (C) 2001, 2002, 2003, 2004, 2005,
3 2006 Free Software Foundation, Inc.
4 Copyright (C) 1995, 1997, 1998, 2002, 2003, 2004, 2005
5 National Institute of Advanced Industrial Science and Technology (AIST)
6 Registration Number H14PRO021
8 National Institute of Advanced Industrial Science and Technology (AIST)
9 Registration Number H13PRO009
11 This file is part of GNU Emacs.
13 GNU Emacs is free software; you can redistribute it and/or modify
14 it under the terms of the GNU General Public License as published by
15 the Free Software Foundation; either version 2, or (at your option)
18 GNU Emacs is distributed in the hope that it will be useful,
19 but WITHOUT ANY WARRANTY; without even the implied warranty of
20 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
21 GNU General Public License for more details.
23 You should have received a copy of the GNU General Public License
24 along with GNU Emacs; see the file COPYING. If not, write to
25 the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
26 Boston, MA 02110-1301, USA. */
28 /*** TABLE OF CONTENTS ***
32 2. Emacs' internal format (emacs-utf-8) handlers
35 5. Charset-base coding systems handlers
36 6. emacs-mule (old Emacs' internal format) handlers
38 8. Shift-JIS and BIG5 handlers
40 10. C library functions
41 11. Emacs Lisp library functions
46 /*** 0. General comments ***
51 A coding system is an object for an encoding mechanism that contains
52 information about how to convert byte sequences to character
53 sequences and vice versa. When we say "decode", it means converting
54 a byte sequence of a specific coding system into a character
55 sequence that is represented by Emacs' internal coding system
56 `emacs-utf-8', and when we say "encode", it means converting a
57 character sequence of emacs-utf-8 to a byte sequence of a specific
60 In Emacs Lisp, a coding system is represented by a Lisp symbol. In
61 C level, a coding system is represented by a vector of attributes
62 stored in the hash table Vcharset_hash_table. The conversion from
63 coding system symbol to attributes vector is done by looking up
64 Vcharset_hash_table by the symbol.
66 Coding systems are classified into the following types depending on
67 the encoding mechanism. Here's a brief description of the types.
73 o Charset-base coding system
75 A coding system defined by one or more (coded) character sets.
76 Decoding and encoding are done by a code converter defined for each
79 o Old Emacs internal format (emacs-mule)
81 The coding system adopted by old versions of Emacs (20 and 21).
83 o ISO2022-base coding system
85 The most famous coding system for multiple character sets. X's
86 Compound Text, various EUCs (Extended Unix Code), and coding systems
87 used in the Internet communication such as ISO-2022-JP are all
90 o SJIS (or Shift-JIS or MS-Kanji-Code)
92 A coding system to encode character sets: ASCII, JISX0201, and
93 JISX0208. Widely used for PC's in Japan. Details are described in
98 A coding system to encode character sets: ASCII and Big5. Widely
99 used for Chinese (mainly in Taiwan and Hong Kong). Details are
100 described in section 8. In this file, when we write "big5" (all
101 lowercase), we mean the coding system, and when we write "Big5"
102 (capitalized), we mean the character set.
106 If a user wants to decode/encode text encoded in a coding system
107 not listed above, he can supply a decoder and an encoder for it in
108 CCL (Code Conversion Language) programs. Emacs executes the CCL
109 program while decoding/encoding.
113 A coding system for text containing raw eight-bit data. Emacs
114 treats each byte of source text as a character (except for
115 end-of-line conversion).
119 Like raw text, but don't do end-of-line conversion.
124 How text end-of-line is encoded depends on operating system. For
125 instance, Unix's format is just one byte of LF (line-feed) code,
126 whereas DOS's format is two-byte sequence of `carriage-return' and
127 `line-feed' codes. MacOS's format is usually one byte of
130 Since text character encoding and end-of-line encoding are
131 independent, any coding system described above can take any format
132 of end-of-line (except for no-conversion).
136 Before using a coding system for code conversion (i.e. decoding and
137 encoding), we setup a structure of type `struct coding_system'.
138 This structure keeps various information about a specific code
139 conversion (e.g. the location of source and destination data).
146 /*** GENERAL NOTES on `detect_coding_XXX ()' functions ***
148 These functions check if a byte sequence specified as a source in
149 CODING conforms to the format of XXX, and update the members of
152 Return 1 if the byte sequence conforms to XXX, otherwise return 0.
154 Below is the template of these functions. */
158 detect_coding_XXX (coding
, detect_info
)
159 struct coding_system
*coding
;
160 struct coding_detection_info
*detect_info
;
162 const unsigned char *src
= coding
->source
;
163 const unsigned char *src_end
= coding
->source
+ coding
->src_bytes
;
164 int multibytep
= coding
->src_multibyte
;
165 int consumed_chars
= 0;
171 /* Get one byte from the source. If the souce is exausted, jump
172 to no_more_source:. */
175 if (! __C_conforms_to_XXX___ (c
))
177 if (! __C_strongly_suggests_XXX__ (c
))
178 found
= CATEGORY_MASK_XXX
;
180 /* The byte sequence is invalid for XXX. */
181 detect_info
->rejected
|= CATEGORY_MASK_XXX
;
185 /* The source exausted successfully. */
186 detect_info
->found
|= found
;
191 /*** GENERAL NOTES on `decode_coding_XXX ()' functions ***
193 These functions decode a byte sequence specified as a source by
194 CODING. The resulting multibyte text goes to a place pointed to by
195 CODING->charbuf, the length of which should not exceed
196 CODING->charbuf_size;
198 These functions set the information of original and decoded texts in
199 CODING->consumed, CODING->consumed_char, and CODING->charbuf_used.
200 They also set CODING->result to one of CODING_RESULT_XXX indicating
201 how the decoding is finished.
203 Below is the template of these functions. */
207 decode_coding_XXXX (coding
)
208 struct coding_system
*coding
;
210 const unsigned char *src
= coding
->source
+ coding
->consumed
;
211 const unsigned char *src_end
= coding
->source
+ coding
->src_bytes
;
212 /* SRC_BASE remembers the start position in source in each loop.
213 The loop will be exited when there's not enough source code, or
214 when there's no room in CHARBUF for a decoded character. */
215 const unsigned char *src_base
;
216 /* A buffer to produce decoded characters. */
217 int *charbuf
= coding
->charbuf
+ coding
->charbuf_used
;
218 int *charbuf_end
= coding
->charbuf
+ coding
->charbuf_size
;
219 int multibytep
= coding
->src_multibyte
;
224 if (charbuf
< charbuf_end
)
225 /* No more room to produce a decoded character. */
232 if (src_base
< src_end
233 && coding
->mode
& CODING_MODE_LAST_BLOCK
)
234 /* If the source ends by partial bytes to construct a character,
235 treat them as eight-bit raw data. */
236 while (src_base
< src_end
&& charbuf
< charbuf_end
)
237 *charbuf
++ = *src_base
++;
238 /* Remember how many bytes and characters we consumed. If the
239 source is multibyte, the bytes and chars are not identical. */
240 coding
->consumed
= coding
->consumed_char
= src_base
- coding
->source
;
241 /* Remember how many characters we produced. */
242 coding
->charbuf_used
= charbuf
- coding
->charbuf
;
246 /*** GENERAL NOTES on `encode_coding_XXX ()' functions ***
248 These functions encode SRC_BYTES length text at SOURCE of Emacs'
249 internal multibyte format by CODING. The resulting byte sequence
250 goes to a place pointed to by DESTINATION, the length of which
251 should not exceed DST_BYTES.
253 These functions set the information of original and encoded texts in
254 the members produced, produced_char, consumed, and consumed_char of
255 the structure *CODING. They also set the member result to one of
256 CODING_RESULT_XXX indicating how the encoding finished.
258 DST_BYTES zero means that source area and destination area are
259 overlapped, which means that we can produce a encoded text until it
260 reaches at the head of not-yet-encoded source text.
262 Below is a template of these functions. */
265 encode_coding_XXX (coding
)
266 struct coding_system
*coding
;
268 int multibytep
= coding
->dst_multibyte
;
269 int *charbuf
= coding
->charbuf
;
270 int *charbuf_end
= charbuf
->charbuf
+ coding
->charbuf_used
;
271 unsigned char *dst
= coding
->destination
+ coding
->produced
;
272 unsigned char *dst_end
= coding
->destination
+ coding
->dst_bytes
;
273 unsigned char *adjusted_dst_end
= dst_end
- _MAX_BYTES_PRODUCED_IN_LOOP_
;
274 int produced_chars
= 0;
276 for (; charbuf
< charbuf_end
&& dst
< adjusted_dst_end
; charbuf
++)
279 /* Encode C into DST, and increment DST. */
281 label_no_more_destination
:
282 /* How many chars and bytes we produced. */
283 coding
->produced_char
+= produced_chars
;
284 coding
->produced
= dst
- coding
->destination
;
289 /*** 1. Preamble ***/
296 #include "character.h"
299 #include "composite.h"
303 Lisp_Object Vcoding_system_hash_table
;
305 Lisp_Object Qcoding_system
, Qcoding_aliases
, Qeol_type
;
306 Lisp_Object Qunix
, Qdos
;
307 extern Lisp_Object Qmac
; /* frame.c */
308 Lisp_Object Qbuffer_file_coding_system
;
309 Lisp_Object Qpost_read_conversion
, Qpre_write_conversion
;
310 Lisp_Object Qdefault_char
;
311 Lisp_Object Qno_conversion
, Qundecided
;
312 Lisp_Object Qcharset
, Qiso_2022
, Qutf_8
, Qutf_16
, Qshift_jis
, Qbig5
;
313 Lisp_Object Qbig
, Qlittle
;
314 Lisp_Object Qcoding_system_history
;
315 Lisp_Object Qvalid_codes
;
316 Lisp_Object QCcategory
, QCmnemonic
, QCdefalut_char
;
317 Lisp_Object QCdecode_translation_table
, QCencode_translation_table
;
318 Lisp_Object QCpost_read_conversion
, QCpre_write_conversion
;
319 Lisp_Object QCascii_compatible_p
;
321 extern Lisp_Object Qinsert_file_contents
, Qwrite_region
;
322 Lisp_Object Qcall_process
, Qcall_process_region
;
323 Lisp_Object Qstart_process
, Qopen_network_stream
;
324 Lisp_Object Qtarget_idx
;
326 Lisp_Object Qinsufficient_source
, Qinconsistent_eol
, Qinvalid_source
;
327 Lisp_Object Qinterrupted
, Qinsufficient_memory
;
329 /* If a symbol has this property, evaluate the value to define the
330 symbol as a coding system. */
331 static Lisp_Object Qcoding_system_define_form
;
333 int coding_system_require_warning
;
335 Lisp_Object Vselect_safe_coding_system_function
;
337 /* Mnemonic string for each format of end-of-line. */
338 Lisp_Object eol_mnemonic_unix
, eol_mnemonic_dos
, eol_mnemonic_mac
;
339 /* Mnemonic string to indicate format of end-of-line is not yet
341 Lisp_Object eol_mnemonic_undecided
;
345 Lisp_Object Vcoding_system_list
, Vcoding_system_alist
;
347 Lisp_Object Qcoding_system_p
, Qcoding_system_error
;
349 /* Coding system emacs-mule and raw-text are for converting only
350 end-of-line format. */
351 Lisp_Object Qemacs_mule
, Qraw_text
;
352 Lisp_Object Qutf_8_emacs
;
354 /* Coding-systems are handed between Emacs Lisp programs and C internal
355 routines by the following three variables. */
356 /* Coding-system for reading files and receiving data from process. */
357 Lisp_Object Vcoding_system_for_read
;
358 /* Coding-system for writing files and sending data to process. */
359 Lisp_Object Vcoding_system_for_write
;
360 /* Coding-system actually used in the latest I/O. */
361 Lisp_Object Vlast_coding_system_used
;
362 /* Set to non-nil when an error is detected while code conversion. */
363 Lisp_Object Vlast_code_conversion_error
;
364 /* A vector of length 256 which contains information about special
365 Latin codes (especially for dealing with Microsoft codes). */
366 Lisp_Object Vlatin_extra_code_table
;
368 /* Flag to inhibit code conversion of end-of-line format. */
369 int inhibit_eol_conversion
;
371 /* Flag to inhibit ISO2022 escape sequence detection. */
372 int inhibit_iso_escape_detection
;
374 /* Flag to make buffer-file-coding-system inherit from process-coding. */
375 int inherit_process_coding_system
;
377 /* Coding system to be used to encode text for terminal display. */
378 struct coding_system terminal_coding
;
380 /* Coding system to be used to encode text for terminal display when
381 terminal coding system is nil. */
382 struct coding_system safe_terminal_coding
;
384 /* Coding system of what is sent from terminal keyboard. */
385 struct coding_system keyboard_coding
;
387 Lisp_Object Vfile_coding_system_alist
;
388 Lisp_Object Vprocess_coding_system_alist
;
389 Lisp_Object Vnetwork_coding_system_alist
;
391 Lisp_Object Vlocale_coding_system
;
395 /* Flag to tell if we look up translation table on character code
397 Lisp_Object Venable_character_translation
;
398 /* Standard translation table to look up on decoding (reading). */
399 Lisp_Object Vstandard_translation_table_for_decode
;
400 /* Standard translation table to look up on encoding (writing). */
401 Lisp_Object Vstandard_translation_table_for_encode
;
403 Lisp_Object Qtranslation_table
;
404 Lisp_Object Qtranslation_table_id
;
405 Lisp_Object Qtranslation_table_for_decode
;
406 Lisp_Object Qtranslation_table_for_encode
;
408 /* Alist of charsets vs revision number. */
409 static Lisp_Object Vcharset_revision_table
;
411 /* Default coding systems used for process I/O. */
412 Lisp_Object Vdefault_process_coding_system
;
414 /* Char table for translating Quail and self-inserting input. */
415 Lisp_Object Vtranslation_table_for_input
;
417 /* Two special coding systems. */
418 Lisp_Object Vsjis_coding_system
;
419 Lisp_Object Vbig5_coding_system
;
421 /* ISO2022 section */
423 #define CODING_ISO_INITIAL(coding, reg) \
424 (XINT (AREF (AREF (CODING_ID_ATTRS ((coding)->id), \
425 coding_attr_iso_initial), \
429 #define CODING_ISO_REQUEST(coding, charset_id) \
430 ((charset_id <= (coding)->max_charset_id \
431 ? (coding)->safe_charsets[charset_id] \
435 #define CODING_ISO_FLAGS(coding) \
436 ((coding)->spec.iso_2022.flags)
437 #define CODING_ISO_DESIGNATION(coding, reg) \
438 ((coding)->spec.iso_2022.current_designation[reg])
439 #define CODING_ISO_INVOCATION(coding, plane) \
440 ((coding)->spec.iso_2022.current_invocation[plane])
441 #define CODING_ISO_SINGLE_SHIFTING(coding) \
442 ((coding)->spec.iso_2022.single_shifting)
443 #define CODING_ISO_BOL(coding) \
444 ((coding)->spec.iso_2022.bol)
445 #define CODING_ISO_INVOKED_CHARSET(coding, plane) \
446 CODING_ISO_DESIGNATION ((coding), CODING_ISO_INVOCATION ((coding), (plane)))
448 /* Control characters of ISO2022. */
449 /* code */ /* function */
450 #define ISO_CODE_LF 0x0A /* line-feed */
451 #define ISO_CODE_CR 0x0D /* carriage-return */
452 #define ISO_CODE_SO 0x0E /* shift-out */
453 #define ISO_CODE_SI 0x0F /* shift-in */
454 #define ISO_CODE_SS2_7 0x19 /* single-shift-2 for 7-bit code */
455 #define ISO_CODE_ESC 0x1B /* escape */
456 #define ISO_CODE_SS2 0x8E /* single-shift-2 */
457 #define ISO_CODE_SS3 0x8F /* single-shift-3 */
458 #define ISO_CODE_CSI 0x9B /* control-sequence-introducer */
460 /* All code (1-byte) of ISO2022 is classified into one of the
462 enum iso_code_class_type
464 ISO_control_0
, /* Control codes in the range
465 0x00..0x1F and 0x7F, except for the
466 following 5 codes. */
467 ISO_shift_out
, /* ISO_CODE_SO (0x0E) */
468 ISO_shift_in
, /* ISO_CODE_SI (0x0F) */
469 ISO_single_shift_2_7
, /* ISO_CODE_SS2_7 (0x19) */
470 ISO_escape
, /* ISO_CODE_SO (0x1B) */
471 ISO_control_1
, /* Control codes in the range
472 0x80..0x9F, except for the
473 following 3 codes. */
474 ISO_single_shift_2
, /* ISO_CODE_SS2 (0x8E) */
475 ISO_single_shift_3
, /* ISO_CODE_SS3 (0x8F) */
476 ISO_control_sequence_introducer
, /* ISO_CODE_CSI (0x9B) */
477 ISO_0x20_or_0x7F
, /* Codes of the values 0x20 or 0x7F. */
478 ISO_graphic_plane_0
, /* Graphic codes in the range 0x21..0x7E. */
479 ISO_0xA0_or_0xFF
, /* Codes of the values 0xA0 or 0xFF. */
480 ISO_graphic_plane_1
/* Graphic codes in the range 0xA1..0xFE. */
483 /** The macros CODING_ISO_FLAG_XXX defines a flag bit of the
484 `iso-flags' attribute of an iso2022 coding system. */
486 /* If set, produce long-form designation sequence (e.g. ESC $ ( A)
487 instead of the correct short-form sequence (e.g. ESC $ A). */
488 #define CODING_ISO_FLAG_LONG_FORM 0x0001
490 /* If set, reset graphic planes and registers at end-of-line to the
492 #define CODING_ISO_FLAG_RESET_AT_EOL 0x0002
494 /* If set, reset graphic planes and registers before any control
495 characters to the initial state. */
496 #define CODING_ISO_FLAG_RESET_AT_CNTL 0x0004
498 /* If set, encode by 7-bit environment. */
499 #define CODING_ISO_FLAG_SEVEN_BITS 0x0008
501 /* If set, use locking-shift function. */
502 #define CODING_ISO_FLAG_LOCKING_SHIFT 0x0010
504 /* If set, use single-shift function. Overwrite
505 CODING_ISO_FLAG_LOCKING_SHIFT. */
506 #define CODING_ISO_FLAG_SINGLE_SHIFT 0x0020
508 /* If set, use designation escape sequence. */
509 #define CODING_ISO_FLAG_DESIGNATION 0x0040
511 /* If set, produce revision number sequence. */
512 #define CODING_ISO_FLAG_REVISION 0x0080
514 /* If set, produce ISO6429's direction specifying sequence. */
515 #define CODING_ISO_FLAG_DIRECTION 0x0100
517 /* If set, assume designation states are reset at beginning of line on
519 #define CODING_ISO_FLAG_INIT_AT_BOL 0x0200
521 /* If set, designation sequence should be placed at beginning of line
523 #define CODING_ISO_FLAG_DESIGNATE_AT_BOL 0x0400
525 /* If set, do not encode unsafe charactes on output. */
526 #define CODING_ISO_FLAG_SAFE 0x0800
528 /* If set, extra latin codes (128..159) are accepted as a valid code
530 #define CODING_ISO_FLAG_LATIN_EXTRA 0x1000
532 #define CODING_ISO_FLAG_COMPOSITION 0x2000
534 #define CODING_ISO_FLAG_EUC_TW_SHIFT 0x4000
536 #define CODING_ISO_FLAG_USE_ROMAN 0x8000
538 #define CODING_ISO_FLAG_USE_OLDJIS 0x10000
540 #define CODING_ISO_FLAG_FULL_SUPPORT 0x100000
542 /* A character to be produced on output if encoding of the original
543 character is prohibited by CODING_ISO_FLAG_SAFE. */
544 #define CODING_INHIBIT_CHARACTER_SUBSTITUTION '?'
548 #define CODING_UTF_16_BOM(coding) \
549 ((coding)->spec.utf_16.bom)
551 #define CODING_UTF_16_ENDIAN(coding) \
552 ((coding)->spec.utf_16.endian)
554 #define CODING_UTF_16_SURROGATE(coding) \
555 ((coding)->spec.utf_16.surrogate)
559 #define CODING_CCL_DECODER(coding) \
560 AREF (CODING_ID_ATTRS ((coding)->id), coding_attr_ccl_decoder)
561 #define CODING_CCL_ENCODER(coding) \
562 AREF (CODING_ID_ATTRS ((coding)->id), coding_attr_ccl_encoder)
563 #define CODING_CCL_VALIDS(coding) \
564 (SDATA (AREF (CODING_ID_ATTRS ((coding)->id), coding_attr_ccl_valids)))
566 /* Index for each coding category in `coding_categories' */
570 coding_category_iso_7
,
571 coding_category_iso_7_tight
,
572 coding_category_iso_8_1
,
573 coding_category_iso_8_2
,
574 coding_category_iso_7_else
,
575 coding_category_iso_8_else
,
576 coding_category_utf_8
,
577 coding_category_utf_16_auto
,
578 coding_category_utf_16_be
,
579 coding_category_utf_16_le
,
580 coding_category_utf_16_be_nosig
,
581 coding_category_utf_16_le_nosig
,
582 coding_category_charset
,
583 coding_category_sjis
,
584 coding_category_big5
,
586 coding_category_emacs_mule
,
587 /* All above are targets of code detection. */
588 coding_category_raw_text
,
589 coding_category_undecided
,
593 /* Definitions of flag bits used in detect_coding_XXXX. */
594 #define CATEGORY_MASK_ISO_7 (1 << coding_category_iso_7)
595 #define CATEGORY_MASK_ISO_7_TIGHT (1 << coding_category_iso_7_tight)
596 #define CATEGORY_MASK_ISO_8_1 (1 << coding_category_iso_8_1)
597 #define CATEGORY_MASK_ISO_8_2 (1 << coding_category_iso_8_2)
598 #define CATEGORY_MASK_ISO_7_ELSE (1 << coding_category_iso_7_else)
599 #define CATEGORY_MASK_ISO_8_ELSE (1 << coding_category_iso_8_else)
600 #define CATEGORY_MASK_UTF_8 (1 << coding_category_utf_8)
601 #define CATEGORY_MASK_UTF_16_AUTO (1 << coding_category_utf_16_auto)
602 #define CATEGORY_MASK_UTF_16_BE (1 << coding_category_utf_16_be)
603 #define CATEGORY_MASK_UTF_16_LE (1 << coding_category_utf_16_le)
604 #define CATEGORY_MASK_UTF_16_BE_NOSIG (1 << coding_category_utf_16_be_nosig)
605 #define CATEGORY_MASK_UTF_16_LE_NOSIG (1 << coding_category_utf_16_le_nosig)
606 #define CATEGORY_MASK_CHARSET (1 << coding_category_charset)
607 #define CATEGORY_MASK_SJIS (1 << coding_category_sjis)
608 #define CATEGORY_MASK_BIG5 (1 << coding_category_big5)
609 #define CATEGORY_MASK_CCL (1 << coding_category_ccl)
610 #define CATEGORY_MASK_EMACS_MULE (1 << coding_category_emacs_mule)
611 #define CATEGORY_MASK_RAW_TEXT (1 << coding_category_raw_text)
613 /* This value is returned if detect_coding_mask () find nothing other
614 than ASCII characters. */
615 #define CATEGORY_MASK_ANY \
616 (CATEGORY_MASK_ISO_7 \
617 | CATEGORY_MASK_ISO_7_TIGHT \
618 | CATEGORY_MASK_ISO_8_1 \
619 | CATEGORY_MASK_ISO_8_2 \
620 | CATEGORY_MASK_ISO_7_ELSE \
621 | CATEGORY_MASK_ISO_8_ELSE \
622 | CATEGORY_MASK_UTF_8 \
623 | CATEGORY_MASK_UTF_16_BE \
624 | CATEGORY_MASK_UTF_16_LE \
625 | CATEGORY_MASK_UTF_16_BE_NOSIG \
626 | CATEGORY_MASK_UTF_16_LE_NOSIG \
627 | CATEGORY_MASK_CHARSET \
628 | CATEGORY_MASK_SJIS \
629 | CATEGORY_MASK_BIG5 \
630 | CATEGORY_MASK_CCL \
631 | CATEGORY_MASK_EMACS_MULE)
634 #define CATEGORY_MASK_ISO_7BIT \
635 (CATEGORY_MASK_ISO_7 | CATEGORY_MASK_ISO_7_TIGHT)
637 #define CATEGORY_MASK_ISO_8BIT \
638 (CATEGORY_MASK_ISO_8_1 | CATEGORY_MASK_ISO_8_2)
640 #define CATEGORY_MASK_ISO_ELSE \
641 (CATEGORY_MASK_ISO_7_ELSE | CATEGORY_MASK_ISO_8_ELSE)
643 #define CATEGORY_MASK_ISO_ESCAPE \
644 (CATEGORY_MASK_ISO_7 \
645 | CATEGORY_MASK_ISO_7_TIGHT \
646 | CATEGORY_MASK_ISO_7_ELSE \
647 | CATEGORY_MASK_ISO_8_ELSE)
649 #define CATEGORY_MASK_ISO \
650 ( CATEGORY_MASK_ISO_7BIT \
651 | CATEGORY_MASK_ISO_8BIT \
652 | CATEGORY_MASK_ISO_ELSE)
654 #define CATEGORY_MASK_UTF_16 \
655 (CATEGORY_MASK_UTF_16_BE \
656 | CATEGORY_MASK_UTF_16_LE \
657 | CATEGORY_MASK_UTF_16_BE_NOSIG \
658 | CATEGORY_MASK_UTF_16_LE_NOSIG)
661 /* List of symbols `coding-category-xxx' ordered by priority. This
662 variable is exposed to Emacs Lisp. */
663 static Lisp_Object Vcoding_category_list
;
665 /* Table of coding categories (Lisp symbols). This variable is for
667 static Lisp_Object Vcoding_category_table
;
669 /* Table of coding-categories ordered by priority. */
670 static enum coding_category coding_priorities
[coding_category_max
];
672 /* Nth element is a coding context for the coding system bound to the
673 Nth coding category. */
674 static struct coding_system coding_categories
[coding_category_max
];
676 /*** Commonly used macros and functions ***/
679 #define min(a, b) ((a) < (b) ? (a) : (b))
682 #define max(a, b) ((a) > (b) ? (a) : (b))
685 #define CODING_GET_INFO(coding, attrs, charset_list) \
687 (attrs) = CODING_ID_ATTRS ((coding)->id); \
688 (charset_list) = CODING_ATTR_CHARSET_LIST (attrs); \
692 /* Safely get one byte from the source text pointed by SRC which ends
693 at SRC_END, and set C to that byte. If there are not enough bytes
694 in the source, it jumps to `no_more_source'. If multibytep is
695 nonzero, and a multibyte character is found at SRC, set C to the
696 negative value of the character code. The caller should declare
697 and set these variables appropriately in advance:
698 src, src_end, multibytep */
700 #define ONE_MORE_BYTE(c) \
702 if (src == src_end) \
704 if (src_base < src) \
705 record_conversion_result \
706 (coding, CODING_RESULT_INSUFFICIENT_SRC); \
707 goto no_more_source; \
710 if (multibytep && (c & 0x80)) \
712 if ((c & 0xFE) == 0xC0) \
713 c = ((c & 1) << 6) | *src++; \
717 c = - string_char (src, &src, NULL); \
718 record_conversion_result \
719 (coding, CODING_RESULT_INVALID_SRC); \
726 #define ONE_MORE_BYTE_NO_CHECK(c) \
729 if (multibytep && (c & 0x80)) \
731 if ((c & 0xFE) == 0xC0) \
732 c = ((c & 1) << 6) | *src++; \
736 c = - string_char (src, &src, NULL); \
737 record_conversion_result \
738 (coding, CODING_RESULT_INVALID_SRC); \
745 /* Store a byte C in the place pointed by DST and increment DST to the
746 next free point, and increment PRODUCED_CHARS. The caller should
747 assure that C is 0..127, and declare and set the variable `dst'
748 appropriately in advance.
752 #define EMIT_ONE_ASCII_BYTE(c) \
759 /* Like EMIT_ONE_ASCII_BYTE byt store two bytes; C1 and C2. */
761 #define EMIT_TWO_ASCII_BYTES(c1, c2) \
763 produced_chars += 2; \
764 *dst++ = (c1), *dst++ = (c2); \
768 /* Store a byte C in the place pointed by DST and increment DST to the
769 next free point, and increment PRODUCED_CHARS. If MULTIBYTEP is
770 nonzero, store in an appropriate multibyte from. The caller should
771 declare and set the variables `dst' and `multibytep' appropriately
774 #define EMIT_ONE_BYTE(c) \
781 ch = BYTE8_TO_CHAR (ch); \
782 CHAR_STRING_ADVANCE (ch, dst); \
789 /* Like EMIT_ONE_BYTE, but emit two bytes; C1 and C2. */
791 #define EMIT_TWO_BYTES(c1, c2) \
793 produced_chars += 2; \
800 ch = BYTE8_TO_CHAR (ch); \
801 CHAR_STRING_ADVANCE (ch, dst); \
804 ch = BYTE8_TO_CHAR (ch); \
805 CHAR_STRING_ADVANCE (ch, dst); \
815 #define EMIT_THREE_BYTES(c1, c2, c3) \
817 EMIT_ONE_BYTE (c1); \
818 EMIT_TWO_BYTES (c2, c3); \
822 #define EMIT_FOUR_BYTES(c1, c2, c3, c4) \
824 EMIT_TWO_BYTES (c1, c2); \
825 EMIT_TWO_BYTES (c3, c4); \
829 /* Prototypes for static functions. */
830 static void record_conversion_result
P_ ((struct coding_system
*coding
,
831 enum coding_result_code result
));
832 static int detect_coding_utf_8
P_ ((struct coding_system
*,
833 struct coding_detection_info
*info
));
834 static void decode_coding_utf_8
P_ ((struct coding_system
*));
835 static int encode_coding_utf_8
P_ ((struct coding_system
*));
837 static int detect_coding_utf_16
P_ ((struct coding_system
*,
838 struct coding_detection_info
*info
));
839 static void decode_coding_utf_16
P_ ((struct coding_system
*));
840 static int encode_coding_utf_16
P_ ((struct coding_system
*));
842 static int detect_coding_iso_2022
P_ ((struct coding_system
*,
843 struct coding_detection_info
*info
));
844 static void decode_coding_iso_2022
P_ ((struct coding_system
*));
845 static int encode_coding_iso_2022
P_ ((struct coding_system
*));
847 static int detect_coding_emacs_mule
P_ ((struct coding_system
*,
848 struct coding_detection_info
*info
));
849 static void decode_coding_emacs_mule
P_ ((struct coding_system
*));
850 static int encode_coding_emacs_mule
P_ ((struct coding_system
*));
852 static int detect_coding_sjis
P_ ((struct coding_system
*,
853 struct coding_detection_info
*info
));
854 static void decode_coding_sjis
P_ ((struct coding_system
*));
855 static int encode_coding_sjis
P_ ((struct coding_system
*));
857 static int detect_coding_big5
P_ ((struct coding_system
*,
858 struct coding_detection_info
*info
));
859 static void decode_coding_big5
P_ ((struct coding_system
*));
860 static int encode_coding_big5
P_ ((struct coding_system
*));
862 static int detect_coding_ccl
P_ ((struct coding_system
*,
863 struct coding_detection_info
*info
));
864 static void decode_coding_ccl
P_ ((struct coding_system
*));
865 static int encode_coding_ccl
P_ ((struct coding_system
*));
867 static void decode_coding_raw_text
P_ ((struct coding_system
*));
868 static int encode_coding_raw_text
P_ ((struct coding_system
*));
870 static void coding_set_source
P_ ((struct coding_system
*));
871 static void coding_set_destination
P_ ((struct coding_system
*));
872 static void coding_alloc_by_realloc
P_ ((struct coding_system
*, EMACS_INT
));
873 static void coding_alloc_by_making_gap
P_ ((struct coding_system
*,
875 static unsigned char *alloc_destination
P_ ((struct coding_system
*,
876 EMACS_INT
, unsigned char *));
877 static void setup_iso_safe_charsets
P_ ((Lisp_Object
));
878 static unsigned char *encode_designation_at_bol
P_ ((struct coding_system
*,
881 static int detect_eol
P_ ((const unsigned char *,
882 EMACS_INT
, enum coding_category
));
883 static Lisp_Object adjust_coding_eol_type
P_ ((struct coding_system
*, int));
884 static void decode_eol
P_ ((struct coding_system
*));
885 static Lisp_Object get_translation_table
P_ ((Lisp_Object
, int, int *));
886 static Lisp_Object get_translation
P_ ((Lisp_Object
, int *, int *,
888 static int produce_chars
P_ ((struct coding_system
*, Lisp_Object
, int));
889 static INLINE
void produce_composition
P_ ((struct coding_system
*, int *,
891 static INLINE
void produce_charset
P_ ((struct coding_system
*, int *,
893 static void produce_annotation
P_ ((struct coding_system
*, EMACS_INT
));
894 static int decode_coding
P_ ((struct coding_system
*));
895 static INLINE
int *handle_composition_annotation
P_ ((EMACS_INT
, EMACS_INT
,
896 struct coding_system
*,
897 int *, EMACS_INT
*));
898 static INLINE
int *handle_charset_annotation
P_ ((EMACS_INT
, EMACS_INT
,
899 struct coding_system
*,
900 int *, EMACS_INT
*));
901 static void consume_chars
P_ ((struct coding_system
*, Lisp_Object
, int));
902 static int encode_coding
P_ ((struct coding_system
*));
903 static Lisp_Object make_conversion_work_buffer
P_ ((int));
904 static Lisp_Object code_conversion_restore
P_ ((Lisp_Object
));
905 static INLINE
int char_encodable_p
P_ ((int, Lisp_Object
));
906 static Lisp_Object make_subsidiaries
P_ ((Lisp_Object
));
909 record_conversion_result (struct coding_system
*coding
,
910 enum coding_result_code result
)
912 coding
->result
= result
;
915 case CODING_RESULT_INSUFFICIENT_SRC
:
916 Vlast_code_conversion_error
= Qinsufficient_source
;
918 case CODING_RESULT_INCONSISTENT_EOL
:
919 Vlast_code_conversion_error
= Qinconsistent_eol
;
921 case CODING_RESULT_INVALID_SRC
:
922 Vlast_code_conversion_error
= Qinvalid_source
;
924 case CODING_RESULT_INTERRUPT
:
925 Vlast_code_conversion_error
= Qinterrupted
;
927 case CODING_RESULT_INSUFFICIENT_MEM
:
928 Vlast_code_conversion_error
= Qinsufficient_memory
;
931 Vlast_code_conversion_error
= intern ("Unknown error");
935 #define CODING_DECODE_CHAR(coding, src, src_base, src_end, charset, code, c) \
937 charset_map_loaded = 0; \
938 c = DECODE_CHAR (charset, code); \
939 if (charset_map_loaded) \
941 const unsigned char *orig = coding->source; \
944 coding_set_source (coding); \
945 offset = coding->source - orig; \
947 src_base += offset; \
953 #define ASSURE_DESTINATION(bytes) \
955 if (dst + (bytes) >= dst_end) \
957 int more_bytes = charbuf_end - charbuf + (bytes); \
959 dst = alloc_destination (coding, more_bytes, dst); \
960 dst_end = coding->destination + coding->dst_bytes; \
967 coding_set_source (coding
)
968 struct coding_system
*coding
;
970 if (BUFFERP (coding
->src_object
))
972 struct buffer
*buf
= XBUFFER (coding
->src_object
);
974 if (coding
->src_pos
< 0)
975 coding
->source
= BUF_GAP_END_ADDR (buf
) + coding
->src_pos_byte
;
977 coding
->source
= BUF_BYTE_ADDRESS (buf
, coding
->src_pos_byte
);
979 else if (STRINGP (coding
->src_object
))
981 coding
->source
= SDATA (coding
->src_object
) + coding
->src_pos_byte
;
984 /* Otherwise, the source is C string and is never relocated
985 automatically. Thus we don't have to update anything. */
990 coding_set_destination (coding
)
991 struct coding_system
*coding
;
993 if (BUFFERP (coding
->dst_object
))
995 if (coding
->src_pos
< 0)
997 coding
->destination
= BEG_ADDR
+ coding
->dst_pos_byte
- 1;
998 coding
->dst_bytes
= (GAP_END_ADDR
999 - (coding
->src_bytes
- coding
->consumed
)
1000 - coding
->destination
);
1004 /* We are sure that coding->dst_pos_byte is before the gap
1006 coding
->destination
= (BUF_BEG_ADDR (XBUFFER (coding
->dst_object
))
1007 + coding
->dst_pos_byte
- 1);
1008 coding
->dst_bytes
= (BUF_GAP_END_ADDR (XBUFFER (coding
->dst_object
))
1009 - coding
->destination
);
1013 /* Otherwise, the destination is C string and is never relocated
1014 automatically. Thus we don't have to update anything. */
1020 coding_alloc_by_realloc (coding
, bytes
)
1021 struct coding_system
*coding
;
1024 coding
->destination
= (unsigned char *) xrealloc (coding
->destination
,
1025 coding
->dst_bytes
+ bytes
);
1026 coding
->dst_bytes
+= bytes
;
1030 coding_alloc_by_making_gap (coding
, bytes
)
1031 struct coding_system
*coding
;
1034 if (BUFFERP (coding
->dst_object
)
1035 && EQ (coding
->src_object
, coding
->dst_object
))
1037 EMACS_INT add
= coding
->src_bytes
- coding
->consumed
;
1039 GAP_SIZE
-= add
; ZV
+= add
; Z
+= add
; ZV_BYTE
+= add
; Z_BYTE
+= add
;
1041 GAP_SIZE
+= add
; ZV
-= add
; Z
-= add
; ZV_BYTE
-= add
; Z_BYTE
-= add
;
1045 Lisp_Object this_buffer
;
1047 this_buffer
= Fcurrent_buffer ();
1048 set_buffer_internal (XBUFFER (coding
->dst_object
));
1050 set_buffer_internal (XBUFFER (this_buffer
));
1055 static unsigned char *
1056 alloc_destination (coding
, nbytes
, dst
)
1057 struct coding_system
*coding
;
1061 EMACS_INT offset
= dst
- coding
->destination
;
1063 if (BUFFERP (coding
->dst_object
))
1064 coding_alloc_by_making_gap (coding
, nbytes
);
1066 coding_alloc_by_realloc (coding
, nbytes
);
1067 record_conversion_result (coding
, CODING_RESULT_SUCCESS
);
1068 coding_set_destination (coding
);
1069 dst
= coding
->destination
+ offset
;
1073 /** Macros for annotations. */
1075 /* Maximum length of annotation data (sum of annotations for
1076 composition and charset). */
1077 #define MAX_ANNOTATION_LENGTH (4 + (MAX_COMPOSITION_COMPONENTS * 2) - 1 + 4)
1079 /* An annotation data is stored in the array coding->charbuf in this
1081 [ -LENGTH ANNOTATION_MASK NCHARS ... ]
1082 LENGTH is the number of elements in the annotation.
1083 ANNOTATION_MASK is one of CODING_ANNOTATE_XXX_MASK.
1084 NCHARS is the number of characters in the text annotated.
1086 The format of the following elements depend on ANNOTATION_MASK.
1088 In the case of CODING_ANNOTATE_COMPOSITION_MASK, these elements
1090 ... METHOD [ COMPOSITION-COMPONENTS ... ]
1091 METHOD is one of enum composition_method.
1092 Optionnal COMPOSITION-COMPONENTS are characters and composition
1095 In the case of CODING_ANNOTATE_CHARSET_MASK, one element CHARSET-ID
1098 #define ADD_ANNOTATION_DATA(buf, len, mask, nchars) \
1100 *(buf)++ = -(len); \
1101 *(buf)++ = (mask); \
1102 *(buf)++ = (nchars); \
1103 coding->annotated = 1; \
1106 #define ADD_COMPOSITION_DATA(buf, nchars, method) \
1108 ADD_ANNOTATION_DATA (buf, 4, CODING_ANNOTATE_COMPOSITION_MASK, nchars); \
1113 #define ADD_CHARSET_DATA(buf, nchars, id) \
1115 ADD_ANNOTATION_DATA (buf, 4, CODING_ANNOTATE_CHARSET_MASK, nchars); \
1120 /*** 2. Emacs' internal format (emacs-utf-8) ***/
1127 /* See the above "GENERAL NOTES on `detect_coding_XXX ()' functions".
1128 Check if a text is encoded in UTF-8. If it is, return 1, else
1131 #define UTF_8_1_OCTET_P(c) ((c) < 0x80)
1132 #define UTF_8_EXTRA_OCTET_P(c) (((c) & 0xC0) == 0x80)
1133 #define UTF_8_2_OCTET_LEADING_P(c) (((c) & 0xE0) == 0xC0)
1134 #define UTF_8_3_OCTET_LEADING_P(c) (((c) & 0xF0) == 0xE0)
1135 #define UTF_8_4_OCTET_LEADING_P(c) (((c) & 0xF8) == 0xF0)
1136 #define UTF_8_5_OCTET_LEADING_P(c) (((c) & 0xFC) == 0xF8)
1139 detect_coding_utf_8 (coding
, detect_info
)
1140 struct coding_system
*coding
;
1141 struct coding_detection_info
*detect_info
;
1143 const unsigned char *src
= coding
->source
, *src_base
;
1144 const unsigned char *src_end
= coding
->source
+ coding
->src_bytes
;
1145 int multibytep
= coding
->src_multibyte
;
1146 int consumed_chars
= 0;
1149 detect_info
->checked
|= CATEGORY_MASK_UTF_8
;
1150 /* A coding system of this category is always ASCII compatible. */
1151 src
+= coding
->head_ascii
;
1155 int c
, c1
, c2
, c3
, c4
;
1159 if (c
< 0 || UTF_8_1_OCTET_P (c
))
1162 if (c1
< 0 || ! UTF_8_EXTRA_OCTET_P (c1
))
1164 if (UTF_8_2_OCTET_LEADING_P (c
))
1166 found
= CATEGORY_MASK_UTF_8
;
1170 if (c2
< 0 || ! UTF_8_EXTRA_OCTET_P (c2
))
1172 if (UTF_8_3_OCTET_LEADING_P (c
))
1174 found
= CATEGORY_MASK_UTF_8
;
1178 if (c3
< 0 || ! UTF_8_EXTRA_OCTET_P (c3
))
1180 if (UTF_8_4_OCTET_LEADING_P (c
))
1182 found
= CATEGORY_MASK_UTF_8
;
1186 if (c4
< 0 || ! UTF_8_EXTRA_OCTET_P (c4
))
1188 if (UTF_8_5_OCTET_LEADING_P (c
))
1190 found
= CATEGORY_MASK_UTF_8
;
1195 detect_info
->rejected
|= CATEGORY_MASK_UTF_8
;
1199 if (src_base
< src
&& coding
->mode
& CODING_MODE_LAST_BLOCK
)
1201 detect_info
->rejected
|= CATEGORY_MASK_UTF_8
;
1204 detect_info
->found
|= found
;
1210 decode_coding_utf_8 (coding
)
1211 struct coding_system
*coding
;
1213 const unsigned char *src
= coding
->source
+ coding
->consumed
;
1214 const unsigned char *src_end
= coding
->source
+ coding
->src_bytes
;
1215 const unsigned char *src_base
;
1216 int *charbuf
= coding
->charbuf
+ coding
->charbuf_used
;
1217 int *charbuf_end
= coding
->charbuf
+ coding
->charbuf_size
;
1218 int consumed_chars
= 0, consumed_chars_base
;
1219 int multibytep
= coding
->src_multibyte
;
1220 Lisp_Object attr
, charset_list
;
1222 CODING_GET_INFO (coding
, attr
, charset_list
);
1226 int c
, c1
, c2
, c3
, c4
, c5
;
1229 consumed_chars_base
= consumed_chars
;
1231 if (charbuf
>= charbuf_end
)
1239 else if (UTF_8_1_OCTET_P(c1
))
1246 if (c2
< 0 || ! UTF_8_EXTRA_OCTET_P (c2
))
1248 if (UTF_8_2_OCTET_LEADING_P (c1
))
1250 c
= ((c1
& 0x1F) << 6) | (c2
& 0x3F);
1251 /* Reject overlong sequences here and below. Encoders
1252 producing them are incorrect, they can be misleading,
1253 and they mess up read/write invariance. */
1260 if (c3
< 0 || ! UTF_8_EXTRA_OCTET_P (c3
))
1262 if (UTF_8_3_OCTET_LEADING_P (c1
))
1264 c
= (((c1
& 0xF) << 12)
1265 | ((c2
& 0x3F) << 6) | (c3
& 0x3F));
1267 || (c
>= 0xd800 && c
< 0xe000)) /* surrogates (invalid) */
1273 if (c4
< 0 || ! UTF_8_EXTRA_OCTET_P (c4
))
1275 if (UTF_8_4_OCTET_LEADING_P (c1
))
1277 c
= (((c1
& 0x7) << 18) | ((c2
& 0x3F) << 12)
1278 | ((c3
& 0x3F) << 6) | (c4
& 0x3F));
1285 if (c5
< 0 || ! UTF_8_EXTRA_OCTET_P (c5
))
1287 if (UTF_8_5_OCTET_LEADING_P (c1
))
1289 c
= (((c1
& 0x3) << 24) | ((c2
& 0x3F) << 18)
1290 | ((c3
& 0x3F) << 12) | ((c4
& 0x3F) << 6)
1292 if ((c
> MAX_CHAR
) || (c
< 0x200000))
1307 consumed_chars
= consumed_chars_base
;
1309 *charbuf
++ = ASCII_BYTE_P (c
) ? c
: BYTE8_TO_CHAR (c
);
1314 coding
->consumed_char
+= consumed_chars_base
;
1315 coding
->consumed
= src_base
- coding
->source
;
1316 coding
->charbuf_used
= charbuf
- coding
->charbuf
;
1321 encode_coding_utf_8 (coding
)
1322 struct coding_system
*coding
;
1324 int multibytep
= coding
->dst_multibyte
;
1325 int *charbuf
= coding
->charbuf
;
1326 int *charbuf_end
= charbuf
+ coding
->charbuf_used
;
1327 unsigned char *dst
= coding
->destination
+ coding
->produced
;
1328 unsigned char *dst_end
= coding
->destination
+ coding
->dst_bytes
;
1329 int produced_chars
= 0;
1334 int safe_room
= MAX_MULTIBYTE_LENGTH
* 2;
1336 while (charbuf
< charbuf_end
)
1338 unsigned char str
[MAX_MULTIBYTE_LENGTH
], *p
, *pend
= str
;
1340 ASSURE_DESTINATION (safe_room
);
1342 if (CHAR_BYTE8_P (c
))
1344 c
= CHAR_TO_BYTE8 (c
);
1349 CHAR_STRING_ADVANCE (c
, pend
);
1350 for (p
= str
; p
< pend
; p
++)
1357 int safe_room
= MAX_MULTIBYTE_LENGTH
;
1359 while (charbuf
< charbuf_end
)
1361 ASSURE_DESTINATION (safe_room
);
1363 if (CHAR_BYTE8_P (c
))
1364 *dst
++ = CHAR_TO_BYTE8 (c
);
1366 dst
+= CHAR_STRING (c
, dst
);
1370 record_conversion_result (coding
, CODING_RESULT_SUCCESS
);
1371 coding
->produced_char
+= produced_chars
;
1372 coding
->produced
= dst
- coding
->destination
;
1377 /* See the above "GENERAL NOTES on `detect_coding_XXX ()' functions".
1378 Check if a text is encoded in one of UTF-16 based coding systems.
1379 If it is, return 1, else return 0. */
1381 #define UTF_16_HIGH_SURROGATE_P(val) \
1382 (((val) & 0xFC00) == 0xD800)
1384 #define UTF_16_LOW_SURROGATE_P(val) \
1385 (((val) & 0xFC00) == 0xDC00)
1387 #define UTF_16_INVALID_P(val) \
1388 (((val) == 0xFFFE) \
1389 || ((val) == 0xFFFF) \
1390 || UTF_16_LOW_SURROGATE_P (val))
1394 detect_coding_utf_16 (coding
, detect_info
)
1395 struct coding_system
*coding
;
1396 struct coding_detection_info
*detect_info
;
1398 const unsigned char *src
= coding
->source
, *src_base
= src
;
1399 const unsigned char *src_end
= coding
->source
+ coding
->src_bytes
;
1400 int multibytep
= coding
->src_multibyte
;
1401 int consumed_chars
= 0;
1404 detect_info
->checked
|= CATEGORY_MASK_UTF_16
;
1405 if (coding
->mode
& CODING_MODE_LAST_BLOCK
1406 && (coding
->src_chars
& 1))
1408 detect_info
->rejected
|= CATEGORY_MASK_UTF_16
;
1414 if ((c1
== 0xFF) && (c2
== 0xFE))
1416 detect_info
->found
|= (CATEGORY_MASK_UTF_16_LE
1417 | CATEGORY_MASK_UTF_16_AUTO
);
1418 detect_info
->rejected
|= (CATEGORY_MASK_UTF_16_BE
1419 | CATEGORY_MASK_UTF_16_BE_NOSIG
1420 | CATEGORY_MASK_UTF_16_LE_NOSIG
);
1422 else if ((c1
== 0xFE) && (c2
== 0xFF))
1424 detect_info
->found
|= (CATEGORY_MASK_UTF_16_BE
1425 | CATEGORY_MASK_UTF_16_AUTO
);
1426 detect_info
->rejected
|= (CATEGORY_MASK_UTF_16_LE
1427 | CATEGORY_MASK_UTF_16_BE_NOSIG
1428 | CATEGORY_MASK_UTF_16_LE_NOSIG
);
1430 else if (c1
>= 0 && c2
>= 0)
1432 detect_info
->rejected
1433 |= (CATEGORY_MASK_UTF_16_BE
| CATEGORY_MASK_UTF_16_LE
);
1440 decode_coding_utf_16 (coding
)
1441 struct coding_system
*coding
;
1443 const unsigned char *src
= coding
->source
+ coding
->consumed
;
1444 const unsigned char *src_end
= coding
->source
+ coding
->src_bytes
;
1445 const unsigned char *src_base
;
1446 int *charbuf
= coding
->charbuf
+ coding
->charbuf_used
;
1447 int *charbuf_end
= coding
->charbuf
+ coding
->charbuf_size
;
1448 int consumed_chars
= 0, consumed_chars_base
;
1449 int multibytep
= coding
->src_multibyte
;
1450 enum utf_16_bom_type bom
= CODING_UTF_16_BOM (coding
);
1451 enum utf_16_endian_type endian
= CODING_UTF_16_ENDIAN (coding
);
1452 int surrogate
= CODING_UTF_16_SURROGATE (coding
);
1453 Lisp_Object attr
, charset_list
;
1455 CODING_GET_INFO (coding
, attr
, charset_list
);
1457 if (bom
== utf_16_with_bom
)
1466 if (endian
== utf_16_big_endian
1467 ? c
!= 0xFEFF : c
!= 0xFFFE)
1469 /* The first two bytes are not BOM. Treat them as bytes
1470 for a normal character. */
1474 CODING_UTF_16_BOM (coding
) = utf_16_without_bom
;
1476 else if (bom
== utf_16_detect_bom
)
1478 /* We have already tried to detect BOM and failed in
1480 CODING_UTF_16_BOM (coding
) = utf_16_without_bom
;
1488 consumed_chars_base
= consumed_chars
;
1490 if (charbuf
+ 2 >= charbuf_end
)
1502 *charbuf
++ = ASCII_BYTE_P (c1
) ? c1
: BYTE8_TO_CHAR (c1
);
1506 c
= (endian
== utf_16_big_endian
1507 ? ((c1
<< 8) | c2
) : ((c2
<< 8) | c1
));
1510 if (! UTF_16_LOW_SURROGATE_P (c
))
1512 if (endian
== utf_16_big_endian
)
1513 c1
= surrogate
>> 8, c2
= surrogate
& 0xFF;
1515 c1
= surrogate
& 0xFF, c2
= surrogate
>> 8;
1519 if (UTF_16_HIGH_SURROGATE_P (c
))
1520 CODING_UTF_16_SURROGATE (coding
) = surrogate
= c
;
1526 c
= ((surrogate
- 0xD800) << 10) | (c
- 0xDC00);
1527 CODING_UTF_16_SURROGATE (coding
) = surrogate
= 0;
1528 *charbuf
++ = 0x10000 + c
;
1533 if (UTF_16_HIGH_SURROGATE_P (c
))
1534 CODING_UTF_16_SURROGATE (coding
) = surrogate
= c
;
1541 coding
->consumed_char
+= consumed_chars_base
;
1542 coding
->consumed
= src_base
- coding
->source
;
1543 coding
->charbuf_used
= charbuf
- coding
->charbuf
;
1547 encode_coding_utf_16 (coding
)
1548 struct coding_system
*coding
;
1550 int multibytep
= coding
->dst_multibyte
;
1551 int *charbuf
= coding
->charbuf
;
1552 int *charbuf_end
= charbuf
+ coding
->charbuf_used
;
1553 unsigned char *dst
= coding
->destination
+ coding
->produced
;
1554 unsigned char *dst_end
= coding
->destination
+ coding
->dst_bytes
;
1556 enum utf_16_bom_type bom
= CODING_UTF_16_BOM (coding
);
1557 int big_endian
= CODING_UTF_16_ENDIAN (coding
) == utf_16_big_endian
;
1558 int produced_chars
= 0;
1559 Lisp_Object attrs
, charset_list
;
1562 CODING_GET_INFO (coding
, attrs
, charset_list
);
1564 if (bom
!= utf_16_without_bom
)
1566 ASSURE_DESTINATION (safe_room
);
1568 EMIT_TWO_BYTES (0xFE, 0xFF);
1570 EMIT_TWO_BYTES (0xFF, 0xFE);
1571 CODING_UTF_16_BOM (coding
) = utf_16_without_bom
;
1574 while (charbuf
< charbuf_end
)
1576 ASSURE_DESTINATION (safe_room
);
1578 if (c
>= MAX_UNICODE_CHAR
)
1579 c
= coding
->default_char
;
1584 EMIT_TWO_BYTES (c
>> 8, c
& 0xFF);
1586 EMIT_TWO_BYTES (c
& 0xFF, c
>> 8);
1593 c1
= (c
>> 10) + 0xD800;
1594 c2
= (c
& 0x3FF) + 0xDC00;
1596 EMIT_FOUR_BYTES (c1
>> 8, c1
& 0xFF, c2
>> 8, c2
& 0xFF);
1598 EMIT_FOUR_BYTES (c1
& 0xFF, c1
>> 8, c2
& 0xFF, c2
>> 8);
1601 record_conversion_result (coding
, CODING_RESULT_SUCCESS
);
1602 coding
->produced
= dst
- coding
->destination
;
1603 coding
->produced_char
+= produced_chars
;
1608 /*** 6. Old Emacs' internal format (emacs-mule) ***/
1610 /* Emacs' internal format for representation of multiple character
1611 sets is a kind of multi-byte encoding, i.e. characters are
1612 represented by variable-length sequences of one-byte codes.
1614 ASCII characters and control characters (e.g. `tab', `newline') are
1615 represented by one-byte sequences which are their ASCII codes, in
1616 the range 0x00 through 0x7F.
1618 8-bit characters of the range 0x80..0x9F are represented by
1619 two-byte sequences of LEADING_CODE_8_BIT_CONTROL and (their 8-bit
1622 8-bit characters of the range 0xA0..0xFF are represented by
1623 one-byte sequences which are their 8-bit code.
1625 The other characters are represented by a sequence of `base
1626 leading-code', optional `extended leading-code', and one or two
1627 `position-code's. The length of the sequence is determined by the
1628 base leading-code. Leading-code takes the range 0x81 through 0x9D,
1629 whereas extended leading-code and position-code take the range 0xA0
1630 through 0xFF. See `charset.h' for more details about leading-code
1633 --- CODE RANGE of Emacs' internal format ---
1637 eight-bit-control LEADING_CODE_8_BIT_CONTROL + 0xA0..0xBF
1638 eight-bit-graphic 0xA0..0xBF
1639 ELSE 0x81..0x9D + [0xA0..0xFF]+
1640 ---------------------------------------------
1642 As this is the internal character representation, the format is
1643 usually not used externally (i.e. in a file or in a data sent to a
1644 process). But, it is possible to have a text externally in this
1645 format (i.e. by encoding by the coding system `emacs-mule').
1647 In that case, a sequence of one-byte codes has a slightly different
1650 At first, all characters in eight-bit-control are represented by
1651 one-byte sequences which are their 8-bit code.
1653 Next, character composition data are represented by the byte
1654 sequence of the form: 0x80 METHOD BYTES CHARS COMPONENT ...,
1656 METHOD is 0xF0 plus one of composition method (enum
1657 composition_method),
1659 BYTES is 0xA0 plus a byte length of this composition data,
1661 CHARS is 0x20 plus a number of characters composed by this
1664 COMPONENTs are characters of multibye form or composition
1665 rules encoded by two-byte of ASCII codes.
1667 In addition, for backward compatibility, the following formats are
1668 also recognized as composition data on decoding.
1671 0x80 0xFF MSEQ RULE MSEQ RULE ... MSEQ
1674 MSEQ is a multibyte form but in these special format:
1675 ASCII: 0xA0 ASCII_CODE+0x80,
1676 other: LEADING_CODE+0x20 FOLLOWING-BYTE ...,
1677 RULE is a one byte code of the range 0xA0..0xF0 that
1678 represents a composition rule.
1681 char emacs_mule_bytes
[256];
1684 emacs_mule_char (coding
, src
, nbytes
, nchars
, id
)
1685 struct coding_system
*coding
;
1686 const unsigned char *src
;
1687 int *nbytes
, *nchars
, *id
;
1689 const unsigned char *src_end
= coding
->source
+ coding
->src_bytes
;
1690 const unsigned char *src_base
= src
;
1691 int multibytep
= coding
->src_multibyte
;
1692 struct charset
*charset
;
1695 int consumed_chars
= 0;
1701 charset
= emacs_mule_charset
[0];
1705 switch (emacs_mule_bytes
[c
])
1708 if (! (charset
= emacs_mule_charset
[c
]))
1717 if (c
== EMACS_MULE_LEADING_CODE_PRIVATE_11
1718 || c
== EMACS_MULE_LEADING_CODE_PRIVATE_12
)
1721 if (c
< 0xA0 || ! (charset
= emacs_mule_charset
[c
]))
1730 if (! (charset
= emacs_mule_charset
[c
]))
1735 code
= (c
& 0x7F) << 8;
1745 if (c
< 0 || ! (charset
= emacs_mule_charset
[c
]))
1750 code
= (c
& 0x7F) << 8;
1759 charset
= CHARSET_FROM_ID (ASCII_BYTE_P (code
)
1760 ? charset_ascii
: charset_eight_bit
);
1766 c
= DECODE_CHAR (charset
, code
);
1770 *nbytes
= src
- src_base
;
1771 *nchars
= consumed_chars
;
1784 /* See the above "GENERAL NOTES on `detect_coding_XXX ()' functions".
1785 Check if a text is encoded in `emacs-mule'. If it is, return 1,
1789 detect_coding_emacs_mule (coding
, detect_info
)
1790 struct coding_system
*coding
;
1791 struct coding_detection_info
*detect_info
;
1793 const unsigned char *src
= coding
->source
, *src_base
;
1794 const unsigned char *src_end
= coding
->source
+ coding
->src_bytes
;
1795 int multibytep
= coding
->src_multibyte
;
1796 int consumed_chars
= 0;
1800 detect_info
->checked
|= CATEGORY_MASK_EMACS_MULE
;
1801 /* A coding system of this category is always ASCII compatible. */
1802 src
+= coding
->head_ascii
;
1812 /* Perhaps the start of composite character. We simple skip
1813 it because analyzing it is too heavy for detecting. But,
1814 at least, we check that the composite character
1815 constitues of more than 4 bytes. */
1816 const unsigned char *src_base
;
1826 if (src
- src_base
<= 4)
1828 found
= CATEGORY_MASK_EMACS_MULE
;
1836 && (c
== ISO_CODE_ESC
|| c
== ISO_CODE_SI
|| c
== ISO_CODE_SO
))
1841 int more_bytes
= emacs_mule_bytes
[*src_base
] - 1;
1843 while (more_bytes
> 0)
1848 src
--; /* Unread the last byte. */
1853 if (more_bytes
!= 0)
1855 found
= CATEGORY_MASK_EMACS_MULE
;
1858 detect_info
->rejected
|= CATEGORY_MASK_EMACS_MULE
;
1862 if (src_base
< src
&& coding
->mode
& CODING_MODE_LAST_BLOCK
)
1864 detect_info
->rejected
|= CATEGORY_MASK_EMACS_MULE
;
1867 detect_info
->found
|= found
;
1872 /* See the above "GENERAL NOTES on `decode_coding_XXX ()' functions". */
1874 /* Decode a character represented as a component of composition
1875 sequence of Emacs 20/21 style at SRC. Set C to that character and
1876 update SRC to the head of next character (or an encoded composition
1877 rule). If SRC doesn't points a composition component, set C to -1.
1878 If SRC points an invalid byte sequence, global exit by a return
1881 #define DECODE_EMACS_MULE_COMPOSITION_CHAR(buf) \
1885 int nbytes, nchars; \
1887 if (src == src_end) \
1889 c = emacs_mule_char (coding, src, &nbytes, &nchars, NULL);\
1894 goto invalid_code; \
1898 consumed_chars += nchars; \
1903 /* Decode a composition rule represented as a component of composition
1904 sequence of Emacs 20 style at SRC. Store the decoded rule in *BUF,
1905 and increment BUF. If SRC points an invalid byte sequence, set C
1908 #define DECODE_EMACS_MULE_COMPOSITION_RULE_20(buf) \
1910 int c, gref, nref; \
1912 if (src >= src_end) \
1913 goto invalid_code; \
1914 ONE_MORE_BYTE_NO_CHECK (c); \
1916 if (c < 0 || c >= 81) \
1917 goto invalid_code; \
1919 gref = c / 9, nref = c % 9; \
1920 *buf++ = COMPOSITION_ENCODE_RULE (gref, nref); \
1924 /* Decode a composition rule represented as a component of composition
1925 sequence of Emacs 21 style at SRC. Store the decoded rule in *BUF,
1926 and increment BUF. If SRC points an invalid byte sequence, set C
1929 #define DECODE_EMACS_MULE_COMPOSITION_RULE_21(buf) \
1933 if (src + 1>= src_end) \
1934 goto invalid_code; \
1935 ONE_MORE_BYTE_NO_CHECK (gref); \
1937 ONE_MORE_BYTE_NO_CHECK (nref); \
1939 if (gref < 0 || gref >= 81 \
1940 || nref < 0 || nref >= 81) \
1941 goto invalid_code; \
1942 *buf++ = COMPOSITION_ENCODE_RULE (gref, nref); \
1946 #define DECODE_EMACS_MULE_21_COMPOSITION(c) \
1948 /* Emacs 21 style format. The first three bytes at SRC are \
1949 (METHOD - 0xF2), (BYTES - 0xA0), (CHARS - 0xA0), where BYTES is \
1950 the byte length of this composition information, CHARS is the \
1951 number of characters composed by this composition. */ \
1952 enum composition_method method = c - 0xF2; \
1953 int *charbuf_base = charbuf; \
1954 int consumed_chars_limit; \
1955 int nbytes, nchars; \
1957 ONE_MORE_BYTE (c); \
1959 goto invalid_code; \
1960 nbytes = c - 0xA0; \
1962 goto invalid_code; \
1963 ONE_MORE_BYTE (c); \
1965 goto invalid_code; \
1966 nchars = c - 0xA0; \
1967 ADD_COMPOSITION_DATA (charbuf, nchars, method); \
1968 consumed_chars_limit = consumed_chars_base + nbytes; \
1969 if (method != COMPOSITION_RELATIVE) \
1972 while (consumed_chars < consumed_chars_limit) \
1974 if (i % 2 && method != COMPOSITION_WITH_ALTCHARS) \
1975 DECODE_EMACS_MULE_COMPOSITION_RULE_21 (charbuf); \
1977 DECODE_EMACS_MULE_COMPOSITION_CHAR (charbuf); \
1980 if (consumed_chars < consumed_chars_limit) \
1981 goto invalid_code; \
1982 charbuf_base[0] -= i; \
1987 #define DECODE_EMACS_MULE_20_RELATIVE_COMPOSITION(c) \
1989 /* Emacs 20 style format for relative composition. */ \
1990 /* Store multibyte form of characters to be composed. */ \
1991 enum composition_method method = COMPOSITION_RELATIVE; \
1992 int components[MAX_COMPOSITION_COMPONENTS * 2 - 1]; \
1993 int *buf = components; \
1997 ONE_MORE_BYTE (c); /* skip 0x80 */ \
1998 for (i = 0; i < MAX_COMPOSITION_COMPONENTS; i++) \
1999 DECODE_EMACS_MULE_COMPOSITION_CHAR (buf); \
2001 goto invalid_code; \
2002 ADD_COMPOSITION_DATA (charbuf, i, method); \
2003 for (j = 0; j < i; j++) \
2004 *charbuf++ = components[j]; \
2008 #define DECODE_EMACS_MULE_20_RULEBASE_COMPOSITION(c) \
2010 /* Emacs 20 style format for rule-base composition. */ \
2011 /* Store multibyte form of characters to be composed. */ \
2012 enum composition_method method = COMPOSITION_WITH_RULE; \
2013 int components[MAX_COMPOSITION_COMPONENTS * 2 - 1]; \
2014 int *buf = components; \
2017 DECODE_EMACS_MULE_COMPOSITION_CHAR (buf); \
2018 for (i = 0; i < MAX_COMPOSITION_COMPONENTS; i++) \
2020 DECODE_EMACS_MULE_COMPOSITION_RULE_20 (buf); \
2021 DECODE_EMACS_MULE_COMPOSITION_CHAR (buf); \
2023 if (i < 1 || (buf - components) % 2 == 0) \
2024 goto invalid_code; \
2025 if (charbuf + i + (i / 2) + 1 < charbuf_end) \
2026 goto no_more_source; \
2027 ADD_COMPOSITION_DATA (buf, i, method); \
2028 for (j = 0; j < i; j++) \
2029 *charbuf++ = components[j]; \
2030 for (j = 0; j < i; j += 2) \
2031 *charbuf++ = components[j]; \
2036 decode_coding_emacs_mule (coding
)
2037 struct coding_system
*coding
;
2039 const unsigned char *src
= coding
->source
+ coding
->consumed
;
2040 const unsigned char *src_end
= coding
->source
+ coding
->src_bytes
;
2041 const unsigned char *src_base
;
2042 int *charbuf
= coding
->charbuf
+ coding
->charbuf_used
;
2044 = coding
->charbuf
+ coding
->charbuf_size
- MAX_ANNOTATION_LENGTH
;
2045 int consumed_chars
= 0, consumed_chars_base
;
2046 int multibytep
= coding
->src_multibyte
;
2047 Lisp_Object attrs
, charset_list
;
2048 int char_offset
= coding
->produced_char
;
2049 int last_offset
= char_offset
;
2050 int last_id
= charset_ascii
;
2052 CODING_GET_INFO (coding
, attrs
, charset_list
);
2059 consumed_chars_base
= consumed_chars
;
2061 if (charbuf
>= charbuf_end
)
2080 if (c
- 0xF2 >= COMPOSITION_RELATIVE
2081 && c
- 0xF2 <= COMPOSITION_WITH_RULE_ALTCHARS
)
2082 DECODE_EMACS_MULE_21_COMPOSITION (c
);
2084 DECODE_EMACS_MULE_20_RELATIVE_COMPOSITION (c
);
2086 DECODE_EMACS_MULE_20_RULEBASE_COMPOSITION (c
);
2090 else if (c
< 0xA0 && emacs_mule_bytes
[c
] > 1)
2096 consumed_chars
= consumed_chars_base
;
2097 c
= emacs_mule_char (coding
, src
, &nbytes
, &nchars
, &id
);
2106 if (last_id
!= charset_ascii
)
2107 ADD_CHARSET_DATA (charbuf
, char_offset
- last_offset
, last_id
);
2109 last_offset
= char_offset
;
2113 consumed_chars
+= nchars
;
2120 consumed_chars
= consumed_chars_base
;
2122 *charbuf
++ = ASCII_BYTE_P (c
) ? c
: BYTE8_TO_CHAR (c
);
2128 if (last_id
!= charset_ascii
)
2129 ADD_CHARSET_DATA (charbuf
, char_offset
- last_offset
, last_id
);
2130 coding
->consumed_char
+= consumed_chars_base
;
2131 coding
->consumed
= src_base
- coding
->source
;
2132 coding
->charbuf_used
= charbuf
- coding
->charbuf
;
2136 #define EMACS_MULE_LEADING_CODES(id, codes) \
2139 codes[0] = id, codes[1] = 0; \
2140 else if (id < 0xE0) \
2141 codes[0] = 0x9A, codes[1] = id; \
2142 else if (id < 0xF0) \
2143 codes[0] = 0x9B, codes[1] = id; \
2144 else if (id < 0xF5) \
2145 codes[0] = 0x9C, codes[1] = id; \
2147 codes[0] = 0x9D, codes[1] = id; \
2152 encode_coding_emacs_mule (coding
)
2153 struct coding_system
*coding
;
2155 int multibytep
= coding
->dst_multibyte
;
2156 int *charbuf
= coding
->charbuf
;
2157 int *charbuf_end
= charbuf
+ coding
->charbuf_used
;
2158 unsigned char *dst
= coding
->destination
+ coding
->produced
;
2159 unsigned char *dst_end
= coding
->destination
+ coding
->dst_bytes
;
2161 int produced_chars
= 0;
2162 Lisp_Object attrs
, charset_list
;
2164 int preferred_charset_id
= -1;
2166 CODING_GET_INFO (coding
, attrs
, charset_list
);
2167 if (! EQ (charset_list
, Vemacs_mule_charset_list
))
2169 CODING_ATTR_CHARSET_LIST (attrs
)
2170 = charset_list
= Vemacs_mule_charset_list
;
2173 while (charbuf
< charbuf_end
)
2175 ASSURE_DESTINATION (safe_room
);
2180 /* Handle an annotation. */
2183 case CODING_ANNOTATE_COMPOSITION_MASK
:
2184 /* Not yet implemented. */
2186 case CODING_ANNOTATE_CHARSET_MASK
:
2187 preferred_charset_id
= charbuf
[3];
2188 if (preferred_charset_id
>= 0
2189 && NILP (Fmemq (make_number (preferred_charset_id
),
2191 preferred_charset_id
= -1;
2200 if (ASCII_CHAR_P (c
))
2201 EMIT_ONE_ASCII_BYTE (c
);
2202 else if (CHAR_BYTE8_P (c
))
2204 c
= CHAR_TO_BYTE8 (c
);
2209 struct charset
*charset
;
2213 unsigned char leading_codes
[2];
2215 if (preferred_charset_id
>= 0)
2217 charset
= CHARSET_FROM_ID (preferred_charset_id
);
2218 if (! CHAR_CHARSET_P (c
, charset
))
2219 charset
= char_charset (c
, charset_list
, NULL
);
2222 charset
= char_charset (c
, charset_list
, &code
);
2225 c
= coding
->default_char
;
2226 if (ASCII_CHAR_P (c
))
2228 EMIT_ONE_ASCII_BYTE (c
);
2231 charset
= char_charset (c
, charset_list
, &code
);
2233 dimension
= CHARSET_DIMENSION (charset
);
2234 emacs_mule_id
= CHARSET_EMACS_MULE_ID (charset
);
2235 EMACS_MULE_LEADING_CODES (emacs_mule_id
, leading_codes
);
2236 EMIT_ONE_BYTE (leading_codes
[0]);
2237 if (leading_codes
[1])
2238 EMIT_ONE_BYTE (leading_codes
[1]);
2240 EMIT_ONE_BYTE (code
| 0x80);
2244 EMIT_ONE_BYTE (code
>> 8);
2245 EMIT_ONE_BYTE (code
& 0xFF);
2249 record_conversion_result (coding
, CODING_RESULT_SUCCESS
);
2250 coding
->produced_char
+= produced_chars
;
2251 coding
->produced
= dst
- coding
->destination
;
2256 /*** 7. ISO2022 handlers ***/
2258 /* The following note describes the coding system ISO2022 briefly.
2259 Since the intention of this note is to help understand the
2260 functions in this file, some parts are NOT ACCURATE or are OVERLY
2261 SIMPLIFIED. For thorough understanding, please refer to the
2262 original document of ISO2022. This is equivalent to the standard
2263 ECMA-35, obtainable from <URL:http://www.ecma.ch/> (*).
2265 ISO2022 provides many mechanisms to encode several character sets
2266 in 7-bit and 8-bit environments. For 7-bit environments, all text
2267 is encoded using bytes less than 128. This may make the encoded
2268 text a little bit longer, but the text passes more easily through
2269 several types of gateway, some of which strip off the MSB (Most
2272 There are two kinds of character sets: control character sets and
2273 graphic character sets. The former contain control characters such
2274 as `newline' and `escape' to provide control functions (control
2275 functions are also provided by escape sequences). The latter
2276 contain graphic characters such as 'A' and '-'. Emacs recognizes
2277 two control character sets and many graphic character sets.
2279 Graphic character sets are classified into one of the following
2280 four classes, according to the number of bytes (DIMENSION) and
2281 number of characters in one dimension (CHARS) of the set:
2282 - DIMENSION1_CHARS94
2283 - DIMENSION1_CHARS96
2284 - DIMENSION2_CHARS94
2285 - DIMENSION2_CHARS96
2287 In addition, each character set is assigned an identification tag,
2288 unique for each set, called the "final character" (denoted as <F>
2289 hereafter). The <F> of each character set is decided by ECMA(*)
2290 when it is registered in ISO. The code range of <F> is 0x30..0x7F
2291 (0x30..0x3F are for private use only).
2293 Note (*): ECMA = European Computer Manufacturers Association
2295 Here are examples of graphic character sets [NAME(<F>)]:
2296 o DIMENSION1_CHARS94 -- ASCII('B'), right-half-of-JISX0201('I'), ...
2297 o DIMENSION1_CHARS96 -- right-half-of-ISO8859-1('A'), ...
2298 o DIMENSION2_CHARS94 -- GB2312('A'), JISX0208('B'), ...
2299 o DIMENSION2_CHARS96 -- none for the moment
2301 A code area (1 byte=8 bits) is divided into 4 areas, C0, GL, C1, and GR.
2302 C0 [0x00..0x1F] -- control character plane 0
2303 GL [0x20..0x7F] -- graphic character plane 0
2304 C1 [0x80..0x9F] -- control character plane 1
2305 GR [0xA0..0xFF] -- graphic character plane 1
2307 A control character set is directly designated and invoked to C0 or
2308 C1 by an escape sequence. The most common case is that:
2309 - ISO646's control character set is designated/invoked to C0, and
2310 - ISO6429's control character set is designated/invoked to C1,
2311 and usually these designations/invocations are omitted in encoded
2312 text. In a 7-bit environment, only C0 can be used, and a control
2313 character for C1 is encoded by an appropriate escape sequence to
2314 fit into the environment. All control characters for C1 are
2315 defined to have corresponding escape sequences.
2317 A graphic character set is at first designated to one of four
2318 graphic registers (G0 through G3), then these graphic registers are
2319 invoked to GL or GR. These designations and invocations can be
2320 done independently. The most common case is that G0 is invoked to
2321 GL, G1 is invoked to GR, and ASCII is designated to G0. Usually
2322 these invocations and designations are omitted in encoded text.
2323 In a 7-bit environment, only GL can be used.
2325 When a graphic character set of CHARS94 is invoked to GL, codes
2326 0x20 and 0x7F of the GL area work as control characters SPACE and
2327 DEL respectively, and codes 0xA0 and 0xFF of the GR area should not
2330 There are two ways of invocation: locking-shift and single-shift.
2331 With locking-shift, the invocation lasts until the next different
2332 invocation, whereas with single-shift, the invocation affects the
2333 following character only and doesn't affect the locking-shift
2334 state. Invocations are done by the following control characters or
2337 ----------------------------------------------------------------------
2338 abbrev function cntrl escape seq description
2339 ----------------------------------------------------------------------
2340 SI/LS0 (shift-in) 0x0F none invoke G0 into GL
2341 SO/LS1 (shift-out) 0x0E none invoke G1 into GL
2342 LS2 (locking-shift-2) none ESC 'n' invoke G2 into GL
2343 LS3 (locking-shift-3) none ESC 'o' invoke G3 into GL
2344 LS1R (locking-shift-1 right) none ESC '~' invoke G1 into GR (*)
2345 LS2R (locking-shift-2 right) none ESC '}' invoke G2 into GR (*)
2346 LS3R (locking-shift 3 right) none ESC '|' invoke G3 into GR (*)
2347 SS2 (single-shift-2) 0x8E ESC 'N' invoke G2 for one char
2348 SS3 (single-shift-3) 0x8F ESC 'O' invoke G3 for one char
2349 ----------------------------------------------------------------------
2350 (*) These are not used by any known coding system.
2352 Control characters for these functions are defined by macros
2353 ISO_CODE_XXX in `coding.h'.
2355 Designations are done by the following escape sequences:
2356 ----------------------------------------------------------------------
2357 escape sequence description
2358 ----------------------------------------------------------------------
2359 ESC '(' <F> designate DIMENSION1_CHARS94<F> to G0
2360 ESC ')' <F> designate DIMENSION1_CHARS94<F> to G1
2361 ESC '*' <F> designate DIMENSION1_CHARS94<F> to G2
2362 ESC '+' <F> designate DIMENSION1_CHARS94<F> to G3
2363 ESC ',' <F> designate DIMENSION1_CHARS96<F> to G0 (*)
2364 ESC '-' <F> designate DIMENSION1_CHARS96<F> to G1
2365 ESC '.' <F> designate DIMENSION1_CHARS96<F> to G2
2366 ESC '/' <F> designate DIMENSION1_CHARS96<F> to G3
2367 ESC '$' '(' <F> designate DIMENSION2_CHARS94<F> to G0 (**)
2368 ESC '$' ')' <F> designate DIMENSION2_CHARS94<F> to G1
2369 ESC '$' '*' <F> designate DIMENSION2_CHARS94<F> to G2
2370 ESC '$' '+' <F> designate DIMENSION2_CHARS94<F> to G3
2371 ESC '$' ',' <F> designate DIMENSION2_CHARS96<F> to G0 (*)
2372 ESC '$' '-' <F> designate DIMENSION2_CHARS96<F> to G1
2373 ESC '$' '.' <F> designate DIMENSION2_CHARS96<F> to G2
2374 ESC '$' '/' <F> designate DIMENSION2_CHARS96<F> to G3
2375 ----------------------------------------------------------------------
2377 In this list, "DIMENSION1_CHARS94<F>" means a graphic character set
2378 of dimension 1, chars 94, and final character <F>, etc...
2380 Note (*): Although these designations are not allowed in ISO2022,
2381 Emacs accepts them on decoding, and produces them on encoding
2382 CHARS96 character sets in a coding system which is characterized as
2383 7-bit environment, non-locking-shift, and non-single-shift.
2385 Note (**): If <F> is '@', 'A', or 'B', the intermediate character
2386 '(' must be omitted. We refer to this as "short-form" hereafter.
2388 Now you may notice that there are a lot of ways of encoding the
2389 same multilingual text in ISO2022. Actually, there exist many
2390 coding systems such as Compound Text (used in X11's inter client
2391 communication, ISO-2022-JP (used in Japanese Internet), ISO-2022-KR
2392 (used in Korean Internet), EUC (Extended UNIX Code, used in Asian
2393 localized platforms), and all of these are variants of ISO2022.
2395 In addition to the above, Emacs handles two more kinds of escape
2396 sequences: ISO6429's direction specification and Emacs' private
2397 sequence for specifying character composition.
2399 ISO6429's direction specification takes the following form:
2400 o CSI ']' -- end of the current direction
2401 o CSI '0' ']' -- end of the current direction
2402 o CSI '1' ']' -- start of left-to-right text
2403 o CSI '2' ']' -- start of right-to-left text
2404 The control character CSI (0x9B: control sequence introducer) is
2405 abbreviated to the escape sequence ESC '[' in a 7-bit environment.
2407 Character composition specification takes the following form:
2408 o ESC '0' -- start relative composition
2409 o ESC '1' -- end composition
2410 o ESC '2' -- start rule-base composition (*)
2411 o ESC '3' -- start relative composition with alternate chars (**)
2412 o ESC '4' -- start rule-base composition with alternate chars (**)
2413 Since these are not standard escape sequences of any ISO standard,
2414 the use of them with these meanings is restricted to Emacs only.
2416 (*) This form is used only in Emacs 20.7 and older versions,
2417 but newer versions can safely decode it.
2418 (**) This form is used only in Emacs 21.1 and newer versions,
2419 and older versions can't decode it.
2421 Here's a list of example usages of these composition escape
2422 sequences (categorized by `enum composition_method').
2424 COMPOSITION_RELATIVE:
2425 ESC 0 CHAR [ CHAR ] ESC 1
2426 COMPOSITION_WITH_RULE:
2427 ESC 2 CHAR [ RULE CHAR ] ESC 1
2428 COMPOSITION_WITH_ALTCHARS:
2429 ESC 3 ALTCHAR [ ALTCHAR ] ESC 0 CHAR [ CHAR ] ESC 1
2430 COMPOSITION_WITH_RULE_ALTCHARS:
2431 ESC 4 ALTCHAR [ RULE ALTCHAR ] ESC 0 CHAR [ CHAR ] ESC 1 */
2433 enum iso_code_class_type iso_code_class
[256];
2435 #define SAFE_CHARSET_P(coding, id) \
2436 ((id) <= (coding)->max_charset_id \
2437 && (coding)->safe_charsets[id] >= 0)
2440 #define SHIFT_OUT_OK(category) \
2441 (CODING_ISO_INITIAL (&coding_categories[category], 1) >= 0)
2444 setup_iso_safe_charsets (attrs
)
2447 Lisp_Object charset_list
, safe_charsets
;
2448 Lisp_Object request
;
2449 Lisp_Object reg_usage
;
2452 int flags
= XINT (AREF (attrs
, coding_attr_iso_flags
));
2455 charset_list
= CODING_ATTR_CHARSET_LIST (attrs
);
2456 if ((flags
& CODING_ISO_FLAG_FULL_SUPPORT
)
2457 && ! EQ (charset_list
, Viso_2022_charset_list
))
2459 CODING_ATTR_CHARSET_LIST (attrs
)
2460 = charset_list
= Viso_2022_charset_list
;
2461 ASET (attrs
, coding_attr_safe_charsets
, Qnil
);
2464 if (STRINGP (AREF (attrs
, coding_attr_safe_charsets
)))
2468 for (tail
= charset_list
; CONSP (tail
); tail
= XCDR (tail
))
2470 int id
= XINT (XCAR (tail
));
2471 if (max_charset_id
< id
)
2472 max_charset_id
= id
;
2475 safe_charsets
= Fmake_string (make_number (max_charset_id
+ 1),
2477 request
= AREF (attrs
, coding_attr_iso_request
);
2478 reg_usage
= AREF (attrs
, coding_attr_iso_usage
);
2479 reg94
= XINT (XCAR (reg_usage
));
2480 reg96
= XINT (XCDR (reg_usage
));
2482 for (tail
= charset_list
; CONSP (tail
); tail
= XCDR (tail
))
2486 struct charset
*charset
;
2489 charset
= CHARSET_FROM_ID (XINT (id
));
2490 reg
= Fcdr (Fassq (id
, request
));
2492 SSET (safe_charsets
, XINT (id
), XINT (reg
));
2493 else if (charset
->iso_chars_96
)
2496 SSET (safe_charsets
, XINT (id
), reg96
);
2501 SSET (safe_charsets
, XINT (id
), reg94
);
2504 ASET (attrs
, coding_attr_safe_charsets
, safe_charsets
);
2508 /* See the above "GENERAL NOTES on `detect_coding_XXX ()' functions".
2509 Check if a text is encoded in one of ISO-2022 based codig systems.
2510 If it is, return 1, else return 0. */
2513 detect_coding_iso_2022 (coding
, detect_info
)
2514 struct coding_system
*coding
;
2515 struct coding_detection_info
*detect_info
;
2517 const unsigned char *src
= coding
->source
, *src_base
= src
;
2518 const unsigned char *src_end
= coding
->source
+ coding
->src_bytes
;
2519 int multibytep
= coding
->src_multibyte
;
2520 int single_shifting
= 0;
2523 int consumed_chars
= 0;
2528 detect_info
->checked
|= CATEGORY_MASK_ISO
;
2530 for (i
= coding_category_iso_7
; i
<= coding_category_iso_8_else
; i
++)
2532 struct coding_system
*this = &(coding_categories
[i
]);
2533 Lisp_Object attrs
, val
;
2535 attrs
= CODING_ID_ATTRS (this->id
);
2536 if (CODING_ISO_FLAGS (this) & CODING_ISO_FLAG_FULL_SUPPORT
2537 && ! EQ (CODING_ATTR_SAFE_CHARSETS (attrs
), Viso_2022_charset_list
))
2538 setup_iso_safe_charsets (attrs
);
2539 val
= CODING_ATTR_SAFE_CHARSETS (attrs
);
2540 this->max_charset_id
= SCHARS (val
) - 1;
2541 this->safe_charsets
= (char *) SDATA (val
);
2544 /* A coding system of this category is always ASCII compatible. */
2545 src
+= coding
->head_ascii
;
2547 while (rejected
!= CATEGORY_MASK_ISO
)
2554 if (inhibit_iso_escape_detection
)
2556 single_shifting
= 0;
2558 if (c
>= '(' && c
<= '/')
2560 /* Designation sequence for a charset of dimension 1. */
2562 if (c1
< ' ' || c1
>= 0x80
2563 || (id
= iso_charset_table
[0][c
>= ','][c1
]) < 0)
2564 /* Invalid designation sequence. Just ignore. */
2569 /* Designation sequence for a charset of dimension 2. */
2571 if (c
>= '@' && c
<= 'B')
2572 /* Designation for JISX0208.1978, GB2312, or JISX0208. */
2573 id
= iso_charset_table
[1][0][c
];
2574 else if (c
>= '(' && c
<= '/')
2577 if (c1
< ' ' || c1
>= 0x80
2578 || (id
= iso_charset_table
[1][c
>= ','][c1
]) < 0)
2579 /* Invalid designation sequence. Just ignore. */
2583 /* Invalid designation sequence. Just ignore it. */
2586 else if (c
== 'N' || c
== 'O')
2588 /* ESC <Fe> for SS2 or SS3. */
2589 single_shifting
= 1;
2590 rejected
|= CATEGORY_MASK_ISO_7BIT
| CATEGORY_MASK_ISO_8BIT
;
2593 else if (c
>= '0' && c
<= '4')
2595 /* ESC <Fp> for start/end composition. */
2596 found
|= CATEGORY_MASK_ISO
;
2601 /* Invalid escape sequence. Just ignore it. */
2605 /* We found a valid designation sequence for CHARSET. */
2606 rejected
|= CATEGORY_MASK_ISO_8BIT
;
2607 if (SAFE_CHARSET_P (&coding_categories
[coding_category_iso_7
],
2609 found
|= CATEGORY_MASK_ISO_7
;
2611 rejected
|= CATEGORY_MASK_ISO_7
;
2612 if (SAFE_CHARSET_P (&coding_categories
[coding_category_iso_7_tight
],
2614 found
|= CATEGORY_MASK_ISO_7_TIGHT
;
2616 rejected
|= CATEGORY_MASK_ISO_7_TIGHT
;
2617 if (SAFE_CHARSET_P (&coding_categories
[coding_category_iso_7_else
],
2619 found
|= CATEGORY_MASK_ISO_7_ELSE
;
2621 rejected
|= CATEGORY_MASK_ISO_7_ELSE
;
2622 if (SAFE_CHARSET_P (&coding_categories
[coding_category_iso_8_else
],
2624 found
|= CATEGORY_MASK_ISO_8_ELSE
;
2626 rejected
|= CATEGORY_MASK_ISO_8_ELSE
;
2631 /* Locking shift out/in. */
2632 if (inhibit_iso_escape_detection
)
2634 single_shifting
= 0;
2635 rejected
|= CATEGORY_MASK_ISO_7BIT
| CATEGORY_MASK_ISO_8BIT
;
2636 found
|= CATEGORY_MASK_ISO_ELSE
;
2640 /* Control sequence introducer. */
2641 single_shifting
= 0;
2642 rejected
|= CATEGORY_MASK_ISO_7BIT
| CATEGORY_MASK_ISO_7_ELSE
;
2643 found
|= CATEGORY_MASK_ISO_8_ELSE
;
2644 goto check_extra_latin
;
2649 if (inhibit_iso_escape_detection
)
2651 single_shifting
= 0;
2652 rejected
|= CATEGORY_MASK_ISO_7BIT
;
2653 if (CODING_ISO_FLAGS (&coding_categories
[coding_category_iso_8_1
])
2654 & CODING_ISO_FLAG_SINGLE_SHIFT
)
2655 found
|= CATEGORY_MASK_ISO_8_1
, single_shifting
= 1;
2656 if (CODING_ISO_FLAGS (&coding_categories
[coding_category_iso_8_2
])
2657 & CODING_ISO_FLAG_SINGLE_SHIFT
)
2658 found
|= CATEGORY_MASK_ISO_8_2
, single_shifting
= 1;
2659 if (single_shifting
)
2661 goto check_extra_latin
;
2668 single_shifting
= 0;
2673 rejected
|= CATEGORY_MASK_ISO_7BIT
| CATEGORY_MASK_ISO_7_ELSE
;
2674 found
|= CATEGORY_MASK_ISO_8_1
;
2675 /* Check the length of succeeding codes of the range
2676 0xA0..0FF. If the byte length is even, we include
2677 CATEGORY_MASK_ISO_8_2 in `found'. We can check this
2678 only when we are not single shifting. */
2679 if (! single_shifting
2680 && ! (rejected
& CATEGORY_MASK_ISO_8_2
))
2683 while (src
< src_end
)
2691 if (i
& 1 && src
< src_end
)
2692 rejected
|= CATEGORY_MASK_ISO_8_2
;
2694 found
|= CATEGORY_MASK_ISO_8_2
;
2699 single_shifting
= 0;
2700 if (! VECTORP (Vlatin_extra_code_table
)
2701 || NILP (XVECTOR (Vlatin_extra_code_table
)->contents
[c
]))
2703 rejected
= CATEGORY_MASK_ISO
;
2706 if (CODING_ISO_FLAGS (&coding_categories
[coding_category_iso_8_1
])
2707 & CODING_ISO_FLAG_LATIN_EXTRA
)
2708 found
|= CATEGORY_MASK_ISO_8_1
;
2710 rejected
|= CATEGORY_MASK_ISO_8_1
;
2711 rejected
|= CATEGORY_MASK_ISO_8_2
;
2714 detect_info
->rejected
|= CATEGORY_MASK_ISO
;
2718 detect_info
->rejected
|= rejected
;
2719 detect_info
->found
|= (found
& ~rejected
);
2724 /* Set designation state into CODING. Set CHARS_96 to -1 if the
2725 escape sequence should be kept. */
2726 #define DECODE_DESIGNATION(reg, dim, chars_96, final) \
2730 if (final < '0' || final >= 128 \
2731 || ((id = ISO_CHARSET_TABLE (dim, chars_96, final)) < 0) \
2732 || !SAFE_CHARSET_P (coding, id)) \
2734 CODING_ISO_DESIGNATION (coding, reg) = -2; \
2738 prev = CODING_ISO_DESIGNATION (coding, reg); \
2739 if (id == charset_jisx0201_roman) \
2741 if (CODING_ISO_FLAGS (coding) & CODING_ISO_FLAG_USE_ROMAN) \
2742 id = charset_ascii; \
2744 else if (id == charset_jisx0208_1978) \
2746 if (CODING_ISO_FLAGS (coding) & CODING_ISO_FLAG_USE_OLDJIS) \
2747 id = charset_jisx0208; \
2749 CODING_ISO_DESIGNATION (coding, reg) = id; \
2750 /* If there was an invalid designation to REG previously, and this \
2751 designation is ASCII to REG, we should keep this designation \
2753 if (prev == -2 && id == charset_ascii) \
2758 #define MAYBE_FINISH_COMPOSITION() \
2761 if (composition_state == COMPOSING_NO) \
2763 /* It is assured that we have enough room for producing \
2764 characters stored in the table `components'. */ \
2765 if (charbuf + component_idx > charbuf_end) \
2766 goto no_more_source; \
2767 composition_state = COMPOSING_NO; \
2768 if (method == COMPOSITION_RELATIVE \
2769 || method == COMPOSITION_WITH_ALTCHARS) \
2771 for (i = 0; i < component_idx; i++) \
2772 *charbuf++ = components[i]; \
2773 char_offset += component_idx; \
2777 for (i = 0; i < component_idx; i += 2) \
2778 *charbuf++ = components[i]; \
2779 char_offset += (component_idx / 2) + 1; \
2784 /* Handle composition start sequence ESC 0, ESC 2, ESC 3, or ESC 4.
2785 ESC 0 : relative composition : ESC 0 CHAR ... ESC 1
2786 ESC 2 : rulebase composition : ESC 2 CHAR RULE CHAR RULE ... CHAR ESC 1
2787 ESC 3 : altchar composition : ESC 3 CHAR ... ESC 0 CHAR ... ESC 1
2788 ESC 4 : alt&rule composition : ESC 4 CHAR RULE ... CHAR ESC 0 CHAR ... ESC 1
2791 #define DECODE_COMPOSITION_START(c1) \
2794 && composition_state == COMPOSING_COMPONENT_RULE) \
2796 component_len = component_idx; \
2797 composition_state = COMPOSING_CHAR; \
2801 const unsigned char *p; \
2803 MAYBE_FINISH_COMPOSITION (); \
2804 if (charbuf + MAX_COMPOSITION_COMPONENTS > charbuf_end) \
2805 goto no_more_source; \
2806 for (p = src; p < src_end - 1; p++) \
2807 if (*p == ISO_CODE_ESC && p[1] == '1') \
2809 if (p == src_end - 1) \
2811 /* The current composition doesn't end in the current \
2813 record_conversion_result \
2814 (coding, CODING_RESULT_INSUFFICIENT_SRC); \
2815 goto no_more_source; \
2818 /* This is surely the start of a composition. */ \
2819 method = (c1 == '0' ? COMPOSITION_RELATIVE \
2820 : c1 == '2' ? COMPOSITION_WITH_RULE \
2821 : c1 == '3' ? COMPOSITION_WITH_ALTCHARS \
2822 : COMPOSITION_WITH_RULE_ALTCHARS); \
2823 composition_state = (c1 <= '2' ? COMPOSING_CHAR \
2824 : COMPOSING_COMPONENT_CHAR); \
2825 component_idx = component_len = 0; \
2830 /* Handle compositoin end sequence ESC 1. */
2832 #define DECODE_COMPOSITION_END() \
2834 int nchars = (component_len > 0 ? component_idx - component_len \
2835 : method == COMPOSITION_RELATIVE ? component_idx \
2836 : (component_idx + 1) / 2); \
2838 int *saved_charbuf = charbuf; \
2840 ADD_COMPOSITION_DATA (charbuf, nchars, method); \
2841 if (method != COMPOSITION_RELATIVE) \
2843 if (component_len == 0) \
2844 for (i = 0; i < component_idx; i++) \
2845 *charbuf++ = components[i]; \
2847 for (i = 0; i < component_len; i++) \
2848 *charbuf++ = components[i]; \
2849 *saved_charbuf = saved_charbuf - charbuf; \
2851 if (method == COMPOSITION_WITH_RULE) \
2852 for (i = 0; i < component_idx; i += 2, char_offset++) \
2853 *charbuf++ = components[i]; \
2855 for (i = component_len; i < component_idx; i++, char_offset++) \
2856 *charbuf++ = components[i]; \
2857 coding->annotated = 1; \
2858 composition_state = COMPOSING_NO; \
2862 /* Decode a composition rule from the byte C1 (and maybe one more byte
2863 from SRC) and store one encoded composition rule in
2864 coding->cmp_data. */
2866 #define DECODE_COMPOSITION_RULE(c1) \
2869 if (c1 < 81) /* old format (before ver.21) */ \
2871 int gref = (c1) / 9; \
2872 int nref = (c1) % 9; \
2873 if (gref == 4) gref = 10; \
2874 if (nref == 4) nref = 10; \
2875 c1 = COMPOSITION_ENCODE_RULE (gref, nref); \
2877 else if (c1 < 93) /* new format (after ver.21) */ \
2879 ONE_MORE_BYTE (c2); \
2880 c1 = COMPOSITION_ENCODE_RULE (c1 - 81, c2 - 32); \
2887 /* See the above "GENERAL NOTES on `decode_coding_XXX ()' functions". */
2890 decode_coding_iso_2022 (coding
)
2891 struct coding_system
*coding
;
2893 const unsigned char *src
= coding
->source
+ coding
->consumed
;
2894 const unsigned char *src_end
= coding
->source
+ coding
->src_bytes
;
2895 const unsigned char *src_base
;
2896 int *charbuf
= coding
->charbuf
+ coding
->charbuf_used
;
2898 = coding
->charbuf
+ coding
->charbuf_size
- 4 - MAX_ANNOTATION_LENGTH
;
2899 int consumed_chars
= 0, consumed_chars_base
;
2900 int multibytep
= coding
->src_multibyte
;
2901 /* Charsets invoked to graphic plane 0 and 1 respectively. */
2902 int charset_id_0
= CODING_ISO_INVOKED_CHARSET (coding
, 0);
2903 int charset_id_1
= CODING_ISO_INVOKED_CHARSET (coding
, 1);
2904 int charset_id_2
, charset_id_3
;
2905 struct charset
*charset
;
2907 /* For handling composition sequence. */
2908 #define COMPOSING_NO 0
2909 #define COMPOSING_CHAR 1
2910 #define COMPOSING_RULE 2
2911 #define COMPOSING_COMPONENT_CHAR 3
2912 #define COMPOSING_COMPONENT_RULE 4
2914 int composition_state
= COMPOSING_NO
;
2915 enum composition_method method
;
2916 int components
[MAX_COMPOSITION_COMPONENTS
* 2 + 1];
2919 Lisp_Object attrs
, charset_list
;
2920 int char_offset
= coding
->produced_char
;
2921 int last_offset
= char_offset
;
2922 int last_id
= charset_ascii
;
2924 CODING_GET_INFO (coding
, attrs
, charset_list
);
2925 setup_iso_safe_charsets (attrs
);
2932 consumed_chars_base
= consumed_chars
;
2934 if (charbuf
>= charbuf_end
)
2941 /* We produce at most one character. */
2942 switch (iso_code_class
[c1
])
2944 case ISO_0x20_or_0x7F
:
2945 if (composition_state
!= COMPOSING_NO
)
2947 if (composition_state
== COMPOSING_RULE
2948 || composition_state
== COMPOSING_COMPONENT_RULE
)
2950 DECODE_COMPOSITION_RULE (c1
);
2951 components
[component_idx
++] = c1
;
2952 composition_state
--;
2956 if (charset_id_0
< 0
2957 || ! CHARSET_ISO_CHARS_96 (CHARSET_FROM_ID (charset_id_0
)))
2958 /* This is SPACE or DEL. */
2959 charset
= CHARSET_FROM_ID (charset_ascii
);
2961 charset
= CHARSET_FROM_ID (charset_id_0
);
2964 case ISO_graphic_plane_0
:
2965 if (composition_state
!= COMPOSING_NO
)
2967 if (composition_state
== COMPOSING_RULE
2968 || composition_state
== COMPOSING_COMPONENT_RULE
)
2970 DECODE_COMPOSITION_RULE (c1
);
2971 components
[component_idx
++] = c1
;
2972 composition_state
--;
2976 if (charset_id_0
< 0)
2977 charset
= CHARSET_FROM_ID (charset_ascii
);
2979 charset
= CHARSET_FROM_ID (charset_id_0
);
2982 case ISO_0xA0_or_0xFF
:
2983 if (charset_id_1
< 0
2984 || ! CHARSET_ISO_CHARS_96 (CHARSET_FROM_ID (charset_id_1
))
2985 || CODING_ISO_FLAGS (coding
) & CODING_ISO_FLAG_SEVEN_BITS
)
2987 /* This is a graphic character, we fall down ... */
2989 case ISO_graphic_plane_1
:
2990 if (charset_id_1
< 0)
2992 charset
= CHARSET_FROM_ID (charset_id_1
);
2996 MAYBE_FINISH_COMPOSITION ();
2997 charset
= CHARSET_FROM_ID (charset_ascii
);
3001 MAYBE_FINISH_COMPOSITION ();
3005 if (! (CODING_ISO_FLAGS (coding
) & CODING_ISO_FLAG_LOCKING_SHIFT
)
3006 || CODING_ISO_DESIGNATION (coding
, 1) < 0)
3008 CODING_ISO_INVOCATION (coding
, 0) = 1;
3009 charset_id_0
= CODING_ISO_INVOKED_CHARSET (coding
, 0);
3013 if (! (CODING_ISO_FLAGS (coding
) & CODING_ISO_FLAG_LOCKING_SHIFT
))
3015 CODING_ISO_INVOCATION (coding
, 0) = 0;
3016 charset_id_0
= CODING_ISO_INVOKED_CHARSET (coding
, 0);
3019 case ISO_single_shift_2_7
:
3020 case ISO_single_shift_2
:
3021 if (! (CODING_ISO_FLAGS (coding
) & CODING_ISO_FLAG_SINGLE_SHIFT
))
3023 /* SS2 is handled as an escape sequence of ESC 'N' */
3025 goto label_escape_sequence
;
3027 case ISO_single_shift_3
:
3028 if (! (CODING_ISO_FLAGS (coding
) & CODING_ISO_FLAG_SINGLE_SHIFT
))
3030 /* SS2 is handled as an escape sequence of ESC 'O' */
3032 goto label_escape_sequence
;
3034 case ISO_control_sequence_introducer
:
3035 /* CSI is handled as an escape sequence of ESC '[' ... */
3037 goto label_escape_sequence
;
3041 label_escape_sequence
:
3042 /* Escape sequences handled here are invocation,
3043 designation, direction specification, and character
3044 composition specification. */
3047 case '&': /* revision of following character set */
3049 if (!(c1
>= '@' && c1
<= '~'))
3052 if (c1
!= ISO_CODE_ESC
)
3055 goto label_escape_sequence
;
3057 case '$': /* designation of 2-byte character set */
3058 if (! (CODING_ISO_FLAGS (coding
) & CODING_ISO_FLAG_DESIGNATION
))
3064 if (c1
>= '@' && c1
<= 'B')
3065 { /* designation of JISX0208.1978, GB2312.1980,
3067 reg
= 0, chars96
= 0;
3069 else if (c1
>= 0x28 && c1
<= 0x2B)
3070 { /* designation of DIMENSION2_CHARS94 character set */
3071 reg
= c1
- 0x28, chars96
= 0;
3074 else if (c1
>= 0x2C && c1
<= 0x2F)
3075 { /* designation of DIMENSION2_CHARS96 character set */
3076 reg
= c1
- 0x2C, chars96
= 1;
3081 DECODE_DESIGNATION (reg
, 2, chars96
, c1
);
3082 /* We must update these variables now. */
3084 charset_id_0
= CODING_ISO_INVOKED_CHARSET (coding
, 0);
3086 charset_id_1
= CODING_ISO_INVOKED_CHARSET (coding
, 1);
3092 case 'n': /* invocation of locking-shift-2 */
3093 if (! (CODING_ISO_FLAGS (coding
) & CODING_ISO_FLAG_LOCKING_SHIFT
)
3094 || CODING_ISO_DESIGNATION (coding
, 2) < 0)
3096 CODING_ISO_INVOCATION (coding
, 0) = 2;
3097 charset_id_0
= CODING_ISO_INVOKED_CHARSET (coding
, 0);
3100 case 'o': /* invocation of locking-shift-3 */
3101 if (! (CODING_ISO_FLAGS (coding
) & CODING_ISO_FLAG_LOCKING_SHIFT
)
3102 || CODING_ISO_DESIGNATION (coding
, 3) < 0)
3104 CODING_ISO_INVOCATION (coding
, 0) = 3;
3105 charset_id_0
= CODING_ISO_INVOKED_CHARSET (coding
, 0);
3108 case 'N': /* invocation of single-shift-2 */
3109 if (! (CODING_ISO_FLAGS (coding
) & CODING_ISO_FLAG_SINGLE_SHIFT
)
3110 || CODING_ISO_DESIGNATION (coding
, 2) < 0)
3112 charset_id_2
= CODING_ISO_DESIGNATION (coding
, 2);
3113 if (charset_id_2
< 0)
3114 charset
= CHARSET_FROM_ID (charset_ascii
);
3116 charset
= CHARSET_FROM_ID (charset_id_2
);
3118 if (c1
< 0x20 || (c1
>= 0x80 && c1
< 0xA0))
3122 case 'O': /* invocation of single-shift-3 */
3123 if (! (CODING_ISO_FLAGS (coding
) & CODING_ISO_FLAG_SINGLE_SHIFT
)
3124 || CODING_ISO_DESIGNATION (coding
, 3) < 0)
3126 charset_id_3
= CODING_ISO_DESIGNATION (coding
, 3);
3127 if (charset_id_3
< 0)
3128 charset
= CHARSET_FROM_ID (charset_ascii
);
3130 charset
= CHARSET_FROM_ID (charset_id_3
);
3132 if (c1
< 0x20 || (c1
>= 0x80 && c1
< 0xA0))
3136 case '0': case '2': case '3': case '4': /* start composition */
3137 if (! (coding
->common_flags
& CODING_ANNOTATE_COMPOSITION_MASK
))
3139 DECODE_COMPOSITION_START (c1
);
3142 case '1': /* end composition */
3143 if (composition_state
== COMPOSING_NO
)
3145 DECODE_COMPOSITION_END ();
3148 case '[': /* specification of direction */
3149 if (! CODING_ISO_FLAGS (coding
) & CODING_ISO_FLAG_DIRECTION
)
3151 /* For the moment, nested direction is not supported.
3152 So, `coding->mode & CODING_MODE_DIRECTION' zero means
3153 left-to-right, and nozero means right-to-left. */
3157 case ']': /* end of the current direction */
3158 coding
->mode
&= ~CODING_MODE_DIRECTION
;
3160 case '0': /* end of the current direction */
3161 case '1': /* start of left-to-right direction */
3164 coding
->mode
&= ~CODING_MODE_DIRECTION
;
3169 case '2': /* start of right-to-left direction */
3172 coding
->mode
|= CODING_MODE_DIRECTION
;
3186 /* CTEXT extended segment:
3187 ESC % / [0-4] M L --ENCODING-NAME-- \002 --BYTES--
3188 We keep these bytes as is for the moment.
3189 They may be decoded by post-read-conversion. */
3193 ONE_MORE_BYTE (dim
);
3196 size
= ((M
- 128) * 128) + (L
- 128);
3197 if (charbuf
+ 8 + size
> charbuf_end
)
3199 *charbuf
++ = ISO_CODE_ESC
;
3203 *charbuf
++ = BYTE8_TO_CHAR (M
);
3204 *charbuf
++ = BYTE8_TO_CHAR (L
);
3208 *charbuf
++ = ASCII_BYTE_P (c1
) ? c1
: BYTE8_TO_CHAR (c1
);
3213 /* XFree86 extension for embedding UTF-8 in CTEXT:
3214 ESC % G --UTF-8-BYTES-- ESC % @
3215 We keep these bytes as is for the moment.
3216 They may be decoded by post-read-conversion. */
3219 if (p
+ 6 > charbuf_end
)
3221 *p
++ = ISO_CODE_ESC
;
3224 while (p
< charbuf_end
)
3227 if (c1
== ISO_CODE_ESC
3228 && src
+ 1 < src_end
3235 *p
++ = ASCII_BYTE_P (c1
) ? c1
: BYTE8_TO_CHAR (c1
);
3237 if (p
+ 3 > charbuf_end
)
3239 *p
++ = ISO_CODE_ESC
;
3250 if (! (CODING_ISO_FLAGS (coding
) & CODING_ISO_FLAG_DESIGNATION
))
3255 if (c1
>= 0x28 && c1
<= 0x2B)
3256 { /* designation of DIMENSION1_CHARS94 character set */
3257 reg
= c1
- 0x28, chars96
= 0;
3260 else if (c1
>= 0x2C && c1
<= 0x2F)
3261 { /* designation of DIMENSION1_CHARS96 character set */
3262 reg
= c1
- 0x2C, chars96
= 1;
3267 DECODE_DESIGNATION (reg
, 1, chars96
, c1
);
3268 /* We must update these variables now. */
3270 charset_id_0
= CODING_ISO_INVOKED_CHARSET (coding
, 0);
3272 charset_id_1
= CODING_ISO_INVOKED_CHARSET (coding
, 1);
3280 if (charset
->id
!= charset_ascii
3281 && last_id
!= charset
->id
)
3283 if (last_id
!= charset_ascii
)
3284 ADD_CHARSET_DATA (charbuf
, char_offset
- last_offset
, last_id
);
3285 last_id
= charset
->id
;
3286 last_offset
= char_offset
;
3289 /* Now we know CHARSET and 1st position code C1 of a character.
3290 Produce a decoded character while getting 2nd position code
3293 if (CHARSET_DIMENSION (charset
) > 1)
3296 if (c2
< 0x20 || (c2
>= 0x80 && c2
< 0xA0))
3297 /* C2 is not in a valid range. */
3299 c1
= (c1
<< 8) | (c2
& 0x7F);
3300 if (CHARSET_DIMENSION (charset
) > 2)
3303 if (c2
< 0x20 || (c2
>= 0x80 && c2
< 0xA0))
3304 /* C2 is not in a valid range. */
3306 c1
= (c1
<< 8) | (c2
& 0x7F);
3310 CODING_DECODE_CHAR (coding
, src
, src_base
, src_end
, charset
, c1
, c
);
3313 MAYBE_FINISH_COMPOSITION ();
3314 for (; src_base
< src
; src_base
++, char_offset
++)
3316 if (ASCII_BYTE_P (*src_base
))
3317 *charbuf
++ = *src_base
;
3319 *charbuf
++ = BYTE8_TO_CHAR (*src_base
);
3322 else if (composition_state
== COMPOSING_NO
)
3329 components
[component_idx
++] = c
;
3330 if (method
== COMPOSITION_WITH_RULE
3331 || (method
== COMPOSITION_WITH_RULE_ALTCHARS
3332 && composition_state
== COMPOSING_COMPONENT_CHAR
))
3333 composition_state
++;
3338 MAYBE_FINISH_COMPOSITION ();
3340 consumed_chars
= consumed_chars_base
;
3342 *charbuf
++ = c
< 0 ? -c
: ASCII_BYTE_P (c
) ? c
: BYTE8_TO_CHAR (c
);
3352 if (last_id
!= charset_ascii
)
3353 ADD_CHARSET_DATA (charbuf
, char_offset
- last_offset
, last_id
);
3354 coding
->consumed_char
+= consumed_chars_base
;
3355 coding
->consumed
= src_base
- coding
->source
;
3356 coding
->charbuf_used
= charbuf
- coding
->charbuf
;
3360 /* ISO2022 encoding stuff. */
3363 It is not enough to say just "ISO2022" on encoding, we have to
3364 specify more details. In Emacs, each coding system of ISO2022
3365 variant has the following specifications:
3366 1. Initial designation to G0 thru G3.
3367 2. Allows short-form designation?
3368 3. ASCII should be designated to G0 before control characters?
3369 4. ASCII should be designated to G0 at end of line?
3370 5. 7-bit environment or 8-bit environment?
3371 6. Use locking-shift?
3372 7. Use Single-shift?
3373 And the following two are only for Japanese:
3374 8. Use ASCII in place of JIS0201-1976-Roman?
3375 9. Use JISX0208-1983 in place of JISX0208-1978?
3376 These specifications are encoded in CODING_ISO_FLAGS (coding) as flag bits
3377 defined by macros CODING_ISO_FLAG_XXX. See `coding.h' for more
3381 /* Produce codes (escape sequence) for designating CHARSET to graphic
3382 register REG at DST, and increment DST. If <final-char> of CHARSET is
3383 '@', 'A', or 'B' and the coding system CODING allows, produce
3384 designation sequence of short-form. */
3386 #define ENCODE_DESIGNATION(charset, reg, coding) \
3388 unsigned char final_char = CHARSET_ISO_FINAL (charset); \
3389 char *intermediate_char_94 = "()*+"; \
3390 char *intermediate_char_96 = ",-./"; \
3391 int revision = -1; \
3394 if (CODING_ISO_FLAGS (coding) & CODING_ISO_FLAG_REVISION) \
3395 revision = CHARSET_ISO_REVISION (charset); \
3397 if (revision >= 0) \
3399 EMIT_TWO_ASCII_BYTES (ISO_CODE_ESC, '&'); \
3400 EMIT_ONE_BYTE ('@' + revision); \
3402 EMIT_ONE_ASCII_BYTE (ISO_CODE_ESC); \
3403 if (CHARSET_DIMENSION (charset) == 1) \
3405 if (! CHARSET_ISO_CHARS_96 (charset)) \
3406 c = intermediate_char_94[reg]; \
3408 c = intermediate_char_96[reg]; \
3409 EMIT_ONE_ASCII_BYTE (c); \
3413 EMIT_ONE_ASCII_BYTE ('$'); \
3414 if (! CHARSET_ISO_CHARS_96 (charset)) \
3416 if (CODING_ISO_FLAGS (coding) & CODING_ISO_FLAG_LONG_FORM \
3418 || final_char < '@' || final_char > 'B') \
3419 EMIT_ONE_ASCII_BYTE (intermediate_char_94[reg]); \
3422 EMIT_ONE_ASCII_BYTE (intermediate_char_96[reg]); \
3424 EMIT_ONE_ASCII_BYTE (final_char); \
3426 CODING_ISO_DESIGNATION (coding, reg) = CHARSET_ID (charset); \
3430 /* The following two macros produce codes (control character or escape
3431 sequence) for ISO2022 single-shift functions (single-shift-2 and
3434 #define ENCODE_SINGLE_SHIFT_2 \
3436 if (CODING_ISO_FLAGS (coding) & CODING_ISO_FLAG_SEVEN_BITS) \
3437 EMIT_TWO_ASCII_BYTES (ISO_CODE_ESC, 'N'); \
3439 EMIT_ONE_BYTE (ISO_CODE_SS2); \
3440 CODING_ISO_SINGLE_SHIFTING (coding) = 1; \
3444 #define ENCODE_SINGLE_SHIFT_3 \
3446 if (CODING_ISO_FLAGS (coding) & CODING_ISO_FLAG_SEVEN_BITS) \
3447 EMIT_TWO_ASCII_BYTES (ISO_CODE_ESC, 'O'); \
3449 EMIT_ONE_BYTE (ISO_CODE_SS3); \
3450 CODING_ISO_SINGLE_SHIFTING (coding) = 1; \
3454 /* The following four macros produce codes (control character or
3455 escape sequence) for ISO2022 locking-shift functions (shift-in,
3456 shift-out, locking-shift-2, and locking-shift-3). */
3458 #define ENCODE_SHIFT_IN \
3460 EMIT_ONE_ASCII_BYTE (ISO_CODE_SI); \
3461 CODING_ISO_INVOCATION (coding, 0) = 0; \
3465 #define ENCODE_SHIFT_OUT \
3467 EMIT_ONE_ASCII_BYTE (ISO_CODE_SO); \
3468 CODING_ISO_INVOCATION (coding, 0) = 1; \
3472 #define ENCODE_LOCKING_SHIFT_2 \
3474 EMIT_TWO_ASCII_BYTES (ISO_CODE_ESC, 'n'); \
3475 CODING_ISO_INVOCATION (coding, 0) = 2; \
3479 #define ENCODE_LOCKING_SHIFT_3 \
3481 EMIT_TWO_ASCII_BYTES (ISO_CODE_ESC, 'n'); \
3482 CODING_ISO_INVOCATION (coding, 0) = 3; \
3486 /* Produce codes for a DIMENSION1 character whose character set is
3487 CHARSET and whose position-code is C1. Designation and invocation
3488 sequences are also produced in advance if necessary. */
3490 #define ENCODE_ISO_CHARACTER_DIMENSION1(charset, c1) \
3492 int id = CHARSET_ID (charset); \
3494 if ((CODING_ISO_FLAGS (coding) & CODING_ISO_FLAG_USE_ROMAN) \
3495 && id == charset_ascii) \
3497 id = charset_jisx0201_roman; \
3498 charset = CHARSET_FROM_ID (id); \
3501 if (CODING_ISO_SINGLE_SHIFTING (coding)) \
3503 if (CODING_ISO_FLAGS (coding) & CODING_ISO_FLAG_SEVEN_BITS) \
3504 EMIT_ONE_ASCII_BYTE (c1 & 0x7F); \
3506 EMIT_ONE_BYTE (c1 | 0x80); \
3507 CODING_ISO_SINGLE_SHIFTING (coding) = 0; \
3510 else if (id == CODING_ISO_INVOKED_CHARSET (coding, 0)) \
3512 EMIT_ONE_ASCII_BYTE (c1 & 0x7F); \
3515 else if (id == CODING_ISO_INVOKED_CHARSET (coding, 1)) \
3517 EMIT_ONE_BYTE (c1 | 0x80); \
3521 /* Since CHARSET is not yet invoked to any graphic planes, we \
3522 must invoke it, or, at first, designate it to some graphic \
3523 register. Then repeat the loop to actually produce the \
3525 dst = encode_invocation_designation (charset, coding, dst, \
3530 /* Produce codes for a DIMENSION2 character whose character set is
3531 CHARSET and whose position-codes are C1 and C2. Designation and
3532 invocation codes are also produced in advance if necessary. */
3534 #define ENCODE_ISO_CHARACTER_DIMENSION2(charset, c1, c2) \
3536 int id = CHARSET_ID (charset); \
3538 if ((CODING_ISO_FLAGS (coding) & CODING_ISO_FLAG_USE_OLDJIS) \
3539 && id == charset_jisx0208) \
3541 id = charset_jisx0208_1978; \
3542 charset = CHARSET_FROM_ID (id); \
3545 if (CODING_ISO_SINGLE_SHIFTING (coding)) \
3547 if (CODING_ISO_FLAGS (coding) & CODING_ISO_FLAG_SEVEN_BITS) \
3548 EMIT_TWO_ASCII_BYTES ((c1) & 0x7F, (c2) & 0x7F); \
3550 EMIT_TWO_BYTES ((c1) | 0x80, (c2) | 0x80); \
3551 CODING_ISO_SINGLE_SHIFTING (coding) = 0; \
3554 else if (id == CODING_ISO_INVOKED_CHARSET (coding, 0)) \
3556 EMIT_TWO_ASCII_BYTES ((c1) & 0x7F, (c2) & 0x7F); \
3559 else if (id == CODING_ISO_INVOKED_CHARSET (coding, 1)) \
3561 EMIT_TWO_BYTES ((c1) | 0x80, (c2) | 0x80); \
3565 /* Since CHARSET is not yet invoked to any graphic planes, we \
3566 must invoke it, or, at first, designate it to some graphic \
3567 register. Then repeat the loop to actually produce the \
3569 dst = encode_invocation_designation (charset, coding, dst, \
3574 #define ENCODE_ISO_CHARACTER(charset, c) \
3576 int code = ENCODE_CHAR ((charset),(c)); \
3578 if (CHARSET_DIMENSION (charset) == 1) \
3579 ENCODE_ISO_CHARACTER_DIMENSION1 ((charset), code); \
3581 ENCODE_ISO_CHARACTER_DIMENSION2 ((charset), code >> 8, code & 0xFF); \
3585 /* Produce designation and invocation codes at a place pointed by DST
3586 to use CHARSET. The element `spec.iso_2022' of *CODING is updated.
3590 encode_invocation_designation (charset
, coding
, dst
, p_nchars
)
3591 struct charset
*charset
;
3592 struct coding_system
*coding
;
3596 int multibytep
= coding
->dst_multibyte
;
3597 int produced_chars
= *p_nchars
;
3598 int reg
; /* graphic register number */
3599 int id
= CHARSET_ID (charset
);
3601 /* At first, check designations. */
3602 for (reg
= 0; reg
< 4; reg
++)
3603 if (id
== CODING_ISO_DESIGNATION (coding
, reg
))
3608 /* CHARSET is not yet designated to any graphic registers. */
3609 /* At first check the requested designation. */
3610 reg
= CODING_ISO_REQUEST (coding
, id
);
3612 /* Since CHARSET requests no special designation, designate it
3613 to graphic register 0. */
3616 ENCODE_DESIGNATION (charset
, reg
, coding
);
3619 if (CODING_ISO_INVOCATION (coding
, 0) != reg
3620 && CODING_ISO_INVOCATION (coding
, 1) != reg
)
3622 /* Since the graphic register REG is not invoked to any graphic
3623 planes, invoke it to graphic plane 0. */
3626 case 0: /* graphic register 0 */
3630 case 1: /* graphic register 1 */
3634 case 2: /* graphic register 2 */
3635 if (CODING_ISO_FLAGS (coding
) & CODING_ISO_FLAG_SINGLE_SHIFT
)
3636 ENCODE_SINGLE_SHIFT_2
;
3638 ENCODE_LOCKING_SHIFT_2
;
3641 case 3: /* graphic register 3 */
3642 if (CODING_ISO_FLAGS (coding
) & CODING_ISO_FLAG_SINGLE_SHIFT
)
3643 ENCODE_SINGLE_SHIFT_3
;
3645 ENCODE_LOCKING_SHIFT_3
;
3650 *p_nchars
= produced_chars
;
3654 /* The following three macros produce codes for indicating direction
3656 #define ENCODE_CONTROL_SEQUENCE_INTRODUCER \
3658 if (CODING_ISO_FLAGS (coding) == CODING_ISO_FLAG_SEVEN_BITS) \
3659 EMIT_TWO_ASCII_BYTES (ISO_CODE_ESC, '['); \
3661 EMIT_ONE_BYTE (ISO_CODE_CSI); \
3665 #define ENCODE_DIRECTION_R2L() \
3667 ENCODE_CONTROL_SEQUENCE_INTRODUCER (dst); \
3668 EMIT_TWO_ASCII_BYTES ('2', ']'); \
3672 #define ENCODE_DIRECTION_L2R() \
3674 ENCODE_CONTROL_SEQUENCE_INTRODUCER (dst); \
3675 EMIT_TWO_ASCII_BYTES ('0', ']'); \
3679 /* Produce codes for designation and invocation to reset the graphic
3680 planes and registers to initial state. */
3681 #define ENCODE_RESET_PLANE_AND_REGISTER() \
3684 struct charset *charset; \
3686 if (CODING_ISO_INVOCATION (coding, 0) != 0) \
3688 for (reg = 0; reg < 4; reg++) \
3689 if (CODING_ISO_INITIAL (coding, reg) >= 0 \
3690 && (CODING_ISO_DESIGNATION (coding, reg) \
3691 != CODING_ISO_INITIAL (coding, reg))) \
3693 charset = CHARSET_FROM_ID (CODING_ISO_INITIAL (coding, reg)); \
3694 ENCODE_DESIGNATION (charset, reg, coding); \
3699 /* Produce designation sequences of charsets in the line started from
3700 SRC to a place pointed by DST, and return updated DST.
3702 If the current block ends before any end-of-line, we may fail to
3703 find all the necessary designations. */
3705 static unsigned char *
3706 encode_designation_at_bol (coding
, charbuf
, charbuf_end
, dst
)
3707 struct coding_system
*coding
;
3708 int *charbuf
, *charbuf_end
;
3711 struct charset
*charset
;
3712 /* Table of charsets to be designated to each graphic register. */
3714 int c
, found
= 0, reg
;
3715 int produced_chars
= 0;
3716 int multibytep
= coding
->dst_multibyte
;
3718 Lisp_Object charset_list
;
3720 attrs
= CODING_ID_ATTRS (coding
->id
);
3721 charset_list
= CODING_ATTR_CHARSET_LIST (attrs
);
3722 if (EQ (charset_list
, Qiso_2022
))
3723 charset_list
= Viso_2022_charset_list
;
3725 for (reg
= 0; reg
< 4; reg
++)
3735 charset
= char_charset (c
, charset_list
, NULL
);
3736 id
= CHARSET_ID (charset
);
3737 reg
= CODING_ISO_REQUEST (coding
, id
);
3738 if (reg
>= 0 && r
[reg
] < 0)
3747 for (reg
= 0; reg
< 4; reg
++)
3749 && CODING_ISO_DESIGNATION (coding
, reg
) != r
[reg
])
3750 ENCODE_DESIGNATION (CHARSET_FROM_ID (r
[reg
]), reg
, coding
);
3756 /* See the above "GENERAL NOTES on `encode_coding_XXX ()' functions". */
3759 encode_coding_iso_2022 (coding
)
3760 struct coding_system
*coding
;
3762 int multibytep
= coding
->dst_multibyte
;
3763 int *charbuf
= coding
->charbuf
;
3764 int *charbuf_end
= charbuf
+ coding
->charbuf_used
;
3765 unsigned char *dst
= coding
->destination
+ coding
->produced
;
3766 unsigned char *dst_end
= coding
->destination
+ coding
->dst_bytes
;
3769 = (CODING_ISO_FLAGS (coding
) & CODING_ISO_FLAG_DESIGNATE_AT_BOL
3770 && CODING_ISO_BOL (coding
));
3771 int produced_chars
= 0;
3772 Lisp_Object attrs
, eol_type
, charset_list
;
3773 int ascii_compatible
;
3775 int preferred_charset_id
= -1;
3777 CODING_GET_INFO (coding
, attrs
, charset_list
);
3778 eol_type
= CODING_ID_EOL_TYPE (coding
->id
);
3779 if (VECTORP (eol_type
))
3782 setup_iso_safe_charsets (attrs
);
3783 /* Charset list may have been changed. */
3784 charset_list
= CODING_ATTR_CHARSET_LIST (attrs
); \
3785 coding
->safe_charsets
= (char *) SDATA (CODING_ATTR_SAFE_CHARSETS(attrs
));
3787 ascii_compatible
= ! NILP (CODING_ATTR_ASCII_COMPAT (attrs
));
3789 while (charbuf
< charbuf_end
)
3791 ASSURE_DESTINATION (safe_room
);
3793 if (bol_designation
)
3795 unsigned char *dst_prev
= dst
;
3797 /* We have to produce designation sequences if any now. */
3798 dst
= encode_designation_at_bol (coding
, charbuf
, charbuf_end
, dst
);
3799 bol_designation
= 0;
3800 /* We are sure that designation sequences are all ASCII bytes. */
3801 produced_chars
+= dst
- dst_prev
;
3808 /* Handle an annotation. */
3811 case CODING_ANNOTATE_COMPOSITION_MASK
:
3812 /* Not yet implemented. */
3814 case CODING_ANNOTATE_CHARSET_MASK
:
3815 preferred_charset_id
= charbuf
[2];
3816 if (preferred_charset_id
>= 0
3817 && NILP (Fmemq (make_number (preferred_charset_id
),
3819 preferred_charset_id
= -1;
3828 /* Now encode the character C. */
3829 if (c
< 0x20 || c
== 0x7F)
3832 || (c
== '\r' && EQ (eol_type
, Qmac
)))
3834 if (CODING_ISO_FLAGS (coding
) & CODING_ISO_FLAG_RESET_AT_EOL
)
3835 ENCODE_RESET_PLANE_AND_REGISTER ();
3836 if (CODING_ISO_FLAGS (coding
) & CODING_ISO_FLAG_INIT_AT_BOL
)
3840 for (i
= 0; i
< 4; i
++)
3841 CODING_ISO_DESIGNATION (coding
, i
)
3842 = CODING_ISO_INITIAL (coding
, i
);
3845 = CODING_ISO_FLAGS (coding
) & CODING_ISO_FLAG_DESIGNATE_AT_BOL
;
3847 else if (CODING_ISO_FLAGS (coding
) & CODING_ISO_FLAG_RESET_AT_CNTL
)
3848 ENCODE_RESET_PLANE_AND_REGISTER ();
3849 EMIT_ONE_ASCII_BYTE (c
);
3851 else if (ASCII_CHAR_P (c
))
3853 if (ascii_compatible
)
3854 EMIT_ONE_ASCII_BYTE (c
);
3857 struct charset
*charset
= CHARSET_FROM_ID (charset_ascii
);
3858 ENCODE_ISO_CHARACTER (charset
, c
);
3861 else if (CHAR_BYTE8_P (c
))
3863 c
= CHAR_TO_BYTE8 (c
);
3868 struct charset
*charset
;
3870 if (preferred_charset_id
>= 0)
3872 charset
= CHARSET_FROM_ID (preferred_charset_id
);
3873 if (! CHAR_CHARSET_P (c
, charset
))
3874 charset
= char_charset (c
, charset_list
, NULL
);
3877 charset
= char_charset (c
, charset_list
, NULL
);
3880 if (coding
->mode
& CODING_MODE_SAFE_ENCODING
)
3882 c
= CODING_INHIBIT_CHARACTER_SUBSTITUTION
;
3883 charset
= CHARSET_FROM_ID (charset_ascii
);
3887 c
= coding
->default_char
;
3888 charset
= char_charset (c
, charset_list
, NULL
);
3891 ENCODE_ISO_CHARACTER (charset
, c
);
3895 if (coding
->mode
& CODING_MODE_LAST_BLOCK
3896 && CODING_ISO_FLAGS (coding
) & CODING_ISO_FLAG_RESET_AT_EOL
)
3898 ASSURE_DESTINATION (safe_room
);
3899 ENCODE_RESET_PLANE_AND_REGISTER ();
3901 record_conversion_result (coding
, CODING_RESULT_SUCCESS
);
3902 CODING_ISO_BOL (coding
) = bol_designation
;
3903 coding
->produced_char
+= produced_chars
;
3904 coding
->produced
= dst
- coding
->destination
;
3909 /*** 8,9. SJIS and BIG5 handlers ***/
3911 /* Although SJIS and BIG5 are not ISO's coding system, they are used
3912 quite widely. So, for the moment, Emacs supports them in the bare
3913 C code. But, in the future, they may be supported only by CCL. */
3915 /* SJIS is a coding system encoding three character sets: ASCII, right
3916 half of JISX0201-Kana, and JISX0208. An ASCII character is encoded
3917 as is. A character of charset katakana-jisx0201 is encoded by
3918 "position-code + 0x80". A character of charset japanese-jisx0208
3919 is encoded in 2-byte but two position-codes are divided and shifted
3920 so that it fit in the range below.
3922 --- CODE RANGE of SJIS ---
3923 (character set) (range)
3925 KATAKANA-JISX0201 0xA0 .. 0xDF
3926 JISX0208 (1st byte) 0x81 .. 0x9F and 0xE0 .. 0xEF
3927 (2nd byte) 0x40 .. 0x7E and 0x80 .. 0xFC
3928 -------------------------------
3932 /* BIG5 is a coding system encoding two character sets: ASCII and
3933 Big5. An ASCII character is encoded as is. Big5 is a two-byte
3934 character set and is encoded in two-byte.
3936 --- CODE RANGE of BIG5 ---
3937 (character set) (range)
3939 Big5 (1st byte) 0xA1 .. 0xFE
3940 (2nd byte) 0x40 .. 0x7E and 0xA1 .. 0xFE
3941 --------------------------
3945 /* See the above "GENERAL NOTES on `detect_coding_XXX ()' functions".
3946 Check if a text is encoded in SJIS. If it is, return
3947 CATEGORY_MASK_SJIS, else return 0. */
3950 detect_coding_sjis (coding
, detect_info
)
3951 struct coding_system
*coding
;
3952 struct coding_detection_info
*detect_info
;
3954 const unsigned char *src
= coding
->source
, *src_base
;
3955 const unsigned char *src_end
= coding
->source
+ coding
->src_bytes
;
3956 int multibytep
= coding
->src_multibyte
;
3957 int consumed_chars
= 0;
3961 detect_info
->checked
|= CATEGORY_MASK_SJIS
;
3962 /* A coding system of this category is always ASCII compatible. */
3963 src
+= coding
->head_ascii
;
3971 if ((c
>= 0x81 && c
<= 0x9F) || (c
>= 0xE0 && c
<= 0xEF))
3974 if (c
< 0x40 || c
== 0x7F || c
> 0xFC)
3976 found
= CATEGORY_MASK_SJIS
;
3978 else if (c
>= 0xA0 && c
< 0xE0)
3979 found
= CATEGORY_MASK_SJIS
;
3983 detect_info
->rejected
|= CATEGORY_MASK_SJIS
;
3987 if (src_base
< src
&& coding
->mode
& CODING_MODE_LAST_BLOCK
)
3989 detect_info
->rejected
|= CATEGORY_MASK_SJIS
;
3992 detect_info
->found
|= found
;
3996 /* See the above "GENERAL NOTES on `detect_coding_XXX ()' functions".
3997 Check if a text is encoded in BIG5. If it is, return
3998 CATEGORY_MASK_BIG5, else return 0. */
4001 detect_coding_big5 (coding
, detect_info
)
4002 struct coding_system
*coding
;
4003 struct coding_detection_info
*detect_info
;
4005 const unsigned char *src
= coding
->source
, *src_base
;
4006 const unsigned char *src_end
= coding
->source
+ coding
->src_bytes
;
4007 int multibytep
= coding
->src_multibyte
;
4008 int consumed_chars
= 0;
4012 detect_info
->checked
|= CATEGORY_MASK_BIG5
;
4013 /* A coding system of this category is always ASCII compatible. */
4014 src
+= coding
->head_ascii
;
4025 if (c
< 0x40 || (c
>= 0x7F && c
<= 0xA0))
4027 found
= CATEGORY_MASK_BIG5
;
4032 detect_info
->rejected
|= CATEGORY_MASK_BIG5
;
4036 if (src_base
< src
&& coding
->mode
& CODING_MODE_LAST_BLOCK
)
4038 detect_info
->rejected
|= CATEGORY_MASK_BIG5
;
4041 detect_info
->found
|= found
;
4045 /* See the above "GENERAL NOTES on `decode_coding_XXX ()' functions".
4046 If SJIS_P is 1, decode SJIS text, else decode BIG5 test. */
4049 decode_coding_sjis (coding
)
4050 struct coding_system
*coding
;
4052 const unsigned char *src
= coding
->source
+ coding
->consumed
;
4053 const unsigned char *src_end
= coding
->source
+ coding
->src_bytes
;
4054 const unsigned char *src_base
;
4055 int *charbuf
= coding
->charbuf
+ coding
->charbuf_used
;
4057 = coding
->charbuf
+ coding
->charbuf_size
- MAX_ANNOTATION_LENGTH
;
4058 int consumed_chars
= 0, consumed_chars_base
;
4059 int multibytep
= coding
->src_multibyte
;
4060 struct charset
*charset_roman
, *charset_kanji
, *charset_kana
;
4061 struct charset
*charset_kanji2
;
4062 Lisp_Object attrs
, charset_list
, val
;
4063 int char_offset
= coding
->produced_char
;
4064 int last_offset
= char_offset
;
4065 int last_id
= charset_ascii
;
4067 CODING_GET_INFO (coding
, attrs
, charset_list
);
4070 charset_roman
= CHARSET_FROM_ID (XINT (XCAR (val
))), val
= XCDR (val
);
4071 charset_kana
= CHARSET_FROM_ID (XINT (XCAR (val
))), val
= XCDR (val
);
4072 charset_kanji
= CHARSET_FROM_ID (XINT (XCAR (val
))), val
= XCDR (val
);
4073 charset_kanji2
= NILP (val
) ? NULL
: CHARSET_FROM_ID (XINT (XCAR (val
)));
4078 struct charset
*charset
;
4081 consumed_chars_base
= consumed_chars
;
4083 if (charbuf
>= charbuf_end
)
4090 charset
= charset_roman
;
4091 else if (c
== 0x80 || c
== 0xA0)
4093 else if (c
>= 0xA1 && c
<= 0xDF)
4095 /* SJIS -> JISX0201-Kana */
4097 charset
= charset_kana
;
4101 /* SJIS -> JISX0208 */
4103 if (c1
< 0x40 || c1
== 0x7F || c1
> 0xFC)
4107 charset
= charset_kanji
;
4109 else if (c
<= 0xFC && charset_kanji2
)
4111 /* SJIS -> JISX0213-2 */
4113 if (c1
< 0x40 || c1
== 0x7F || c1
> 0xFC)
4117 charset
= charset_kanji2
;
4121 if (charset
->id
!= charset_ascii
4122 && last_id
!= charset
->id
)
4124 if (last_id
!= charset_ascii
)
4125 ADD_CHARSET_DATA (charbuf
, char_offset
- last_offset
, last_id
);
4126 last_id
= charset
->id
;
4127 last_offset
= char_offset
;
4129 CODING_DECODE_CHAR (coding
, src
, src_base
, src_end
, charset
, c
, c
);
4136 consumed_chars
= consumed_chars_base
;
4138 *charbuf
++ = c
< 0 ? -c
: BYTE8_TO_CHAR (c
);
4144 if (last_id
!= charset_ascii
)
4145 ADD_CHARSET_DATA (charbuf
, char_offset
- last_offset
, last_id
);
4146 coding
->consumed_char
+= consumed_chars_base
;
4147 coding
->consumed
= src_base
- coding
->source
;
4148 coding
->charbuf_used
= charbuf
- coding
->charbuf
;
4152 decode_coding_big5 (coding
)
4153 struct coding_system
*coding
;
4155 const unsigned char *src
= coding
->source
+ coding
->consumed
;
4156 const unsigned char *src_end
= coding
->source
+ coding
->src_bytes
;
4157 const unsigned char *src_base
;
4158 int *charbuf
= coding
->charbuf
+ coding
->charbuf_used
;
4160 = coding
->charbuf
+ coding
->charbuf_size
- MAX_ANNOTATION_LENGTH
;
4161 int consumed_chars
= 0, consumed_chars_base
;
4162 int multibytep
= coding
->src_multibyte
;
4163 struct charset
*charset_roman
, *charset_big5
;
4164 Lisp_Object attrs
, charset_list
, val
;
4165 int char_offset
= coding
->produced_char
;
4166 int last_offset
= char_offset
;
4167 int last_id
= charset_ascii
;
4169 CODING_GET_INFO (coding
, attrs
, charset_list
);
4171 charset_roman
= CHARSET_FROM_ID (XINT (XCAR (val
))), val
= XCDR (val
);
4172 charset_big5
= CHARSET_FROM_ID (XINT (XCAR (val
)));
4177 struct charset
*charset
;
4180 consumed_chars_base
= consumed_chars
;
4182 if (charbuf
>= charbuf_end
)
4190 charset
= charset_roman
;
4194 if (c
< 0xA1 || c
> 0xFE)
4197 if (c1
< 0x40 || (c1
> 0x7E && c1
< 0xA1) || c1
> 0xFE)
4200 charset
= charset_big5
;
4202 if (charset
->id
!= charset_ascii
4203 && last_id
!= charset
->id
)
4205 if (last_id
!= charset_ascii
)
4206 ADD_CHARSET_DATA (charbuf
, char_offset
- last_offset
, last_id
);
4207 last_id
= charset
->id
;
4208 last_offset
= char_offset
;
4210 CODING_DECODE_CHAR (coding
, src
, src_base
, src_end
, charset
, c
, c
);
4217 consumed_chars
= consumed_chars_base
;
4219 *charbuf
++ = c
< 0 ? -c
: BYTE8_TO_CHAR (c
);
4225 if (last_id
!= charset_ascii
)
4226 ADD_CHARSET_DATA (charbuf
, char_offset
- last_offset
, last_id
);
4227 coding
->consumed_char
+= consumed_chars_base
;
4228 coding
->consumed
= src_base
- coding
->source
;
4229 coding
->charbuf_used
= charbuf
- coding
->charbuf
;
4232 /* See the above "GENERAL NOTES on `encode_coding_XXX ()' functions".
4233 This function can encode charsets `ascii', `katakana-jisx0201',
4234 `japanese-jisx0208', `chinese-big5-1', and `chinese-big5-2'. We
4235 are sure that all these charsets are registered as official charset
4236 (i.e. do not have extended leading-codes). Characters of other
4237 charsets are produced without any encoding. If SJIS_P is 1, encode
4238 SJIS text, else encode BIG5 text. */
4241 encode_coding_sjis (coding
)
4242 struct coding_system
*coding
;
4244 int multibytep
= coding
->dst_multibyte
;
4245 int *charbuf
= coding
->charbuf
;
4246 int *charbuf_end
= charbuf
+ coding
->charbuf_used
;
4247 unsigned char *dst
= coding
->destination
+ coding
->produced
;
4248 unsigned char *dst_end
= coding
->destination
+ coding
->dst_bytes
;
4250 int produced_chars
= 0;
4251 Lisp_Object attrs
, charset_list
, val
;
4252 int ascii_compatible
;
4253 struct charset
*charset_roman
, *charset_kanji
, *charset_kana
;
4254 struct charset
*charset_kanji2
;
4257 CODING_GET_INFO (coding
, attrs
, charset_list
);
4259 charset_roman
= CHARSET_FROM_ID (XINT (XCAR (val
))), val
= XCDR (val
);
4260 charset_kana
= CHARSET_FROM_ID (XINT (XCAR (val
))), val
= XCDR (val
);
4261 charset_kanji
= CHARSET_FROM_ID (XINT (XCAR (val
))), val
= XCDR (val
);
4262 charset_kanji2
= NILP (val
) ? NULL
: CHARSET_FROM_ID (XINT (XCAR (val
)));
4264 ascii_compatible
= ! NILP (CODING_ATTR_ASCII_COMPAT (attrs
));
4266 while (charbuf
< charbuf_end
)
4268 ASSURE_DESTINATION (safe_room
);
4270 /* Now encode the character C. */
4271 if (ASCII_CHAR_P (c
) && ascii_compatible
)
4272 EMIT_ONE_ASCII_BYTE (c
);
4273 else if (CHAR_BYTE8_P (c
))
4275 c
= CHAR_TO_BYTE8 (c
);
4281 struct charset
*charset
= char_charset (c
, charset_list
, &code
);
4285 if (coding
->mode
& CODING_MODE_SAFE_ENCODING
)
4287 code
= CODING_INHIBIT_CHARACTER_SUBSTITUTION
;
4288 charset
= CHARSET_FROM_ID (charset_ascii
);
4292 c
= coding
->default_char
;
4293 charset
= char_charset (c
, charset_list
, &code
);
4296 if (code
== CHARSET_INVALID_CODE (charset
))
4298 if (charset
== charset_kanji
)
4302 c1
= code
>> 8, c2
= code
& 0xFF;
4303 EMIT_TWO_BYTES (c1
, c2
);
4305 else if (charset
== charset_kana
)
4306 EMIT_ONE_BYTE (code
| 0x80);
4307 else if (charset_kanji2
&& charset
== charset_kanji2
)
4312 if (c1
== 0x21 || (c1
>= 0x23 && c1
< 0x25)
4313 || (c1
>= 0x2C && c1
<= 0x2F) || c1
>= 0x6E)
4315 JIS_TO_SJIS2 (code
);
4316 c1
= code
>> 8, c2
= code
& 0xFF;
4317 EMIT_TWO_BYTES (c1
, c2
);
4320 EMIT_ONE_ASCII_BYTE (code
& 0x7F);
4323 EMIT_ONE_ASCII_BYTE (code
& 0x7F);
4326 record_conversion_result (coding
, CODING_RESULT_SUCCESS
);
4327 coding
->produced_char
+= produced_chars
;
4328 coding
->produced
= dst
- coding
->destination
;
4333 encode_coding_big5 (coding
)
4334 struct coding_system
*coding
;
4336 int multibytep
= coding
->dst_multibyte
;
4337 int *charbuf
= coding
->charbuf
;
4338 int *charbuf_end
= charbuf
+ coding
->charbuf_used
;
4339 unsigned char *dst
= coding
->destination
+ coding
->produced
;
4340 unsigned char *dst_end
= coding
->destination
+ coding
->dst_bytes
;
4342 int produced_chars
= 0;
4343 Lisp_Object attrs
, charset_list
, val
;
4344 int ascii_compatible
;
4345 struct charset
*charset_roman
, *charset_big5
;
4348 CODING_GET_INFO (coding
, attrs
, charset_list
);
4350 charset_roman
= CHARSET_FROM_ID (XINT (XCAR (val
))), val
= XCDR (val
);
4351 charset_big5
= CHARSET_FROM_ID (XINT (XCAR (val
)));
4352 ascii_compatible
= ! NILP (CODING_ATTR_ASCII_COMPAT (attrs
));
4354 while (charbuf
< charbuf_end
)
4356 ASSURE_DESTINATION (safe_room
);
4358 /* Now encode the character C. */
4359 if (ASCII_CHAR_P (c
) && ascii_compatible
)
4360 EMIT_ONE_ASCII_BYTE (c
);
4361 else if (CHAR_BYTE8_P (c
))
4363 c
= CHAR_TO_BYTE8 (c
);
4369 struct charset
*charset
= char_charset (c
, charset_list
, &code
);
4373 if (coding
->mode
& CODING_MODE_SAFE_ENCODING
)
4375 code
= CODING_INHIBIT_CHARACTER_SUBSTITUTION
;
4376 charset
= CHARSET_FROM_ID (charset_ascii
);
4380 c
= coding
->default_char
;
4381 charset
= char_charset (c
, charset_list
, &code
);
4384 if (code
== CHARSET_INVALID_CODE (charset
))
4386 if (charset
== charset_big5
)
4390 c1
= code
>> 8, c2
= code
& 0xFF;
4391 EMIT_TWO_BYTES (c1
, c2
);
4394 EMIT_ONE_ASCII_BYTE (code
& 0x7F);
4397 record_conversion_result (coding
, CODING_RESULT_SUCCESS
);
4398 coding
->produced_char
+= produced_chars
;
4399 coding
->produced
= dst
- coding
->destination
;
4404 /*** 10. CCL handlers ***/
4406 /* See the above "GENERAL NOTES on `detect_coding_XXX ()' functions".
4407 Check if a text is encoded in a coding system of which
4408 encoder/decoder are written in CCL program. If it is, return
4409 CATEGORY_MASK_CCL, else return 0. */
4412 detect_coding_ccl (coding
, detect_info
)
4413 struct coding_system
*coding
;
4414 struct coding_detection_info
*detect_info
;
4416 const unsigned char *src
= coding
->source
, *src_base
;
4417 const unsigned char *src_end
= coding
->source
+ coding
->src_bytes
;
4418 int multibytep
= coding
->src_multibyte
;
4419 int consumed_chars
= 0;
4421 unsigned char *valids
;
4422 int head_ascii
= coding
->head_ascii
;
4425 detect_info
->checked
|= CATEGORY_MASK_CCL
;
4427 coding
= &coding_categories
[coding_category_ccl
];
4428 valids
= CODING_CCL_VALIDS (coding
);
4429 attrs
= CODING_ID_ATTRS (coding
->id
);
4430 if (! NILP (CODING_ATTR_ASCII_COMPAT (attrs
)))
4439 if (c
< 0 || ! valids
[c
])
4441 if ((valids
[c
] > 1))
4442 found
= CATEGORY_MASK_CCL
;
4444 detect_info
->rejected
|= CATEGORY_MASK_CCL
;
4448 detect_info
->found
|= found
;
4453 decode_coding_ccl (coding
)
4454 struct coding_system
*coding
;
4456 const unsigned char *src
= coding
->source
+ coding
->consumed
;
4457 const unsigned char *src_end
= coding
->source
+ coding
->src_bytes
;
4458 int *charbuf
= coding
->charbuf
+ coding
->charbuf_used
;
4459 int *charbuf_end
= coding
->charbuf
+ coding
->charbuf_size
;
4460 int consumed_chars
= 0;
4461 int multibytep
= coding
->src_multibyte
;
4462 struct ccl_program ccl
;
4463 int source_charbuf
[1024];
4464 int source_byteidx
[1024];
4465 Lisp_Object attrs
, charset_list
;
4467 CODING_GET_INFO (coding
, attrs
, charset_list
);
4468 setup_ccl_program (&ccl
, CODING_CCL_DECODER (coding
));
4470 while (src
< src_end
)
4472 const unsigned char *p
= src
;
4473 int *source
, *source_end
;
4477 while (i
< 1024 && p
< src_end
)
4479 source_byteidx
[i
] = p
- src
;
4480 source_charbuf
[i
++] = STRING_CHAR_ADVANCE (p
);
4483 while (i
< 1024 && p
< src_end
)
4484 source_charbuf
[i
++] = *p
++;
4486 if (p
== src_end
&& coding
->mode
& CODING_MODE_LAST_BLOCK
)
4489 source
= source_charbuf
;
4490 source_end
= source
+ i
;
4491 while (source
< source_end
)
4493 ccl_driver (&ccl
, source
, charbuf
,
4494 source_end
- source
, charbuf_end
- charbuf
,
4496 source
+= ccl
.consumed
;
4497 charbuf
+= ccl
.produced
;
4498 if (ccl
.status
!= CCL_STAT_SUSPEND_BY_DST
)
4501 if (source
< source_end
)
4502 src
+= source_byteidx
[source
- source_charbuf
];
4505 consumed_chars
+= source
- source_charbuf
;
4507 if (ccl
.status
!= CCL_STAT_SUSPEND_BY_SRC
4508 && ccl
.status
!= CODING_RESULT_INSUFFICIENT_SRC
)
4514 case CCL_STAT_SUSPEND_BY_SRC
:
4515 record_conversion_result (coding
, CODING_RESULT_INSUFFICIENT_SRC
);
4517 case CCL_STAT_SUSPEND_BY_DST
:
4520 case CCL_STAT_INVALID_CMD
:
4521 record_conversion_result (coding
, CODING_RESULT_INTERRUPT
);
4524 record_conversion_result (coding
, CODING_RESULT_SUCCESS
);
4527 coding
->consumed_char
+= consumed_chars
;
4528 coding
->consumed
= src
- coding
->source
;
4529 coding
->charbuf_used
= charbuf
- coding
->charbuf
;
4533 encode_coding_ccl (coding
)
4534 struct coding_system
*coding
;
4536 struct ccl_program ccl
;
4537 int multibytep
= coding
->dst_multibyte
;
4538 int *charbuf
= coding
->charbuf
;
4539 int *charbuf_end
= charbuf
+ coding
->charbuf_used
;
4540 unsigned char *dst
= coding
->destination
+ coding
->produced
;
4541 unsigned char *dst_end
= coding
->destination
+ coding
->dst_bytes
;
4542 int destination_charbuf
[1024];
4543 int i
, produced_chars
= 0;
4544 Lisp_Object attrs
, charset_list
;
4546 CODING_GET_INFO (coding
, attrs
, charset_list
);
4547 setup_ccl_program (&ccl
, CODING_CCL_ENCODER (coding
));
4549 ccl
.last_block
= coding
->mode
& CODING_MODE_LAST_BLOCK
;
4550 ccl
.dst_multibyte
= coding
->dst_multibyte
;
4552 while (charbuf
< charbuf_end
)
4554 ccl_driver (&ccl
, charbuf
, destination_charbuf
,
4555 charbuf_end
- charbuf
, 1024, charset_list
);
4558 ASSURE_DESTINATION (ccl
.produced
* 2);
4559 for (i
= 0; i
< ccl
.produced
; i
++)
4560 EMIT_ONE_BYTE (destination_charbuf
[i
] & 0xFF);
4564 ASSURE_DESTINATION (ccl
.produced
);
4565 for (i
= 0; i
< ccl
.produced
; i
++)
4566 *dst
++ = destination_charbuf
[i
] & 0xFF;
4567 produced_chars
+= ccl
.produced
;
4569 charbuf
+= ccl
.consumed
;
4570 if (ccl
.status
== CCL_STAT_QUIT
4571 || ccl
.status
== CCL_STAT_INVALID_CMD
)
4577 case CCL_STAT_SUSPEND_BY_SRC
:
4578 record_conversion_result (coding
, CODING_RESULT_INSUFFICIENT_SRC
);
4580 case CCL_STAT_SUSPEND_BY_DST
:
4581 record_conversion_result (coding
, CODING_RESULT_INSUFFICIENT_DST
);
4584 case CCL_STAT_INVALID_CMD
:
4585 record_conversion_result (coding
, CODING_RESULT_INTERRUPT
);
4588 record_conversion_result (coding
, CODING_RESULT_SUCCESS
);
4592 coding
->produced_char
+= produced_chars
;
4593 coding
->produced
= dst
- coding
->destination
;
4599 /*** 10, 11. no-conversion handlers ***/
4601 /* See the above "GENERAL NOTES on `decode_coding_XXX ()' functions". */
4604 decode_coding_raw_text (coding
)
4605 struct coding_system
*coding
;
4607 coding
->chars_at_source
= 1;
4608 coding
->consumed_char
= 0;
4609 coding
->consumed
= 0;
4610 record_conversion_result (coding
, CODING_RESULT_SUCCESS
);
4614 encode_coding_raw_text (coding
)
4615 struct coding_system
*coding
;
4617 int multibytep
= coding
->dst_multibyte
;
4618 int *charbuf
= coding
->charbuf
;
4619 int *charbuf_end
= coding
->charbuf
+ coding
->charbuf_used
;
4620 unsigned char *dst
= coding
->destination
+ coding
->produced
;
4621 unsigned char *dst_end
= coding
->destination
+ coding
->dst_bytes
;
4622 int produced_chars
= 0;
4627 int safe_room
= MAX_MULTIBYTE_LENGTH
* 2;
4629 if (coding
->src_multibyte
)
4630 while (charbuf
< charbuf_end
)
4632 ASSURE_DESTINATION (safe_room
);
4634 if (ASCII_CHAR_P (c
))
4635 EMIT_ONE_ASCII_BYTE (c
);
4636 else if (CHAR_BYTE8_P (c
))
4638 c
= CHAR_TO_BYTE8 (c
);
4643 unsigned char str
[MAX_MULTIBYTE_LENGTH
], *p0
= str
, *p1
= str
;
4645 CHAR_STRING_ADVANCE (c
, p1
);
4648 EMIT_ONE_BYTE (*p0
);
4654 while (charbuf
< charbuf_end
)
4656 ASSURE_DESTINATION (safe_room
);
4663 if (coding
->src_multibyte
)
4665 int safe_room
= MAX_MULTIBYTE_LENGTH
;
4667 while (charbuf
< charbuf_end
)
4669 ASSURE_DESTINATION (safe_room
);
4671 if (ASCII_CHAR_P (c
))
4673 else if (CHAR_BYTE8_P (c
))
4674 *dst
++ = CHAR_TO_BYTE8 (c
);
4676 CHAR_STRING_ADVANCE (c
, dst
);
4682 ASSURE_DESTINATION (charbuf_end
- charbuf
);
4683 while (charbuf
< charbuf_end
&& dst
< dst_end
)
4684 *dst
++ = *charbuf
++;
4685 produced_chars
= dst
- (coding
->destination
+ coding
->dst_bytes
);
4688 record_conversion_result (coding
, CODING_RESULT_SUCCESS
);
4689 coding
->produced_char
+= produced_chars
;
4690 coding
->produced
= dst
- coding
->destination
;
4694 /* See the above "GENERAL NOTES on `detect_coding_XXX ()' functions".
4695 Check if a text is encoded in a charset-based coding system. If it
4696 is, return 1, else return 0. */
4699 detect_coding_charset (coding
, detect_info
)
4700 struct coding_system
*coding
;
4701 struct coding_detection_info
*detect_info
;
4703 const unsigned char *src
= coding
->source
, *src_base
;
4704 const unsigned char *src_end
= coding
->source
+ coding
->src_bytes
;
4705 int multibytep
= coding
->src_multibyte
;
4706 int consumed_chars
= 0;
4707 Lisp_Object attrs
, valids
;
4710 detect_info
->checked
|= CATEGORY_MASK_CHARSET
;
4712 coding
= &coding_categories
[coding_category_charset
];
4713 attrs
= CODING_ID_ATTRS (coding
->id
);
4714 valids
= AREF (attrs
, coding_attr_charset_valids
);
4716 if (! NILP (CODING_ATTR_ASCII_COMPAT (attrs
)))
4717 src
+= coding
->head_ascii
;
4727 if (NILP (AREF (valids
, c
)))
4730 found
= CATEGORY_MASK_CHARSET
;
4732 detect_info
->rejected
|= CATEGORY_MASK_CHARSET
;
4736 detect_info
->found
|= found
;
4741 decode_coding_charset (coding
)
4742 struct coding_system
*coding
;
4744 const unsigned char *src
= coding
->source
+ coding
->consumed
;
4745 const unsigned char *src_end
= coding
->source
+ coding
->src_bytes
;
4746 const unsigned char *src_base
;
4747 int *charbuf
= coding
->charbuf
+ coding
->charbuf_used
;
4749 = coding
->charbuf
+ coding
->charbuf_size
- MAX_ANNOTATION_LENGTH
;
4750 int consumed_chars
= 0, consumed_chars_base
;
4751 int multibytep
= coding
->src_multibyte
;
4752 Lisp_Object attrs
, charset_list
, valids
;
4753 int char_offset
= coding
->produced_char
;
4754 int last_offset
= char_offset
;
4755 int last_id
= charset_ascii
;
4757 CODING_GET_INFO (coding
, attrs
, charset_list
);
4758 valids
= AREF (attrs
, coding_attr_charset_valids
);
4764 struct charset
*charset
;
4770 consumed_chars_base
= consumed_chars
;
4772 if (charbuf
>= charbuf_end
)
4780 val
= AREF (valids
, c
);
4785 charset
= CHARSET_FROM_ID (XFASTINT (val
));
4786 dim
= CHARSET_DIMENSION (charset
);
4790 code
= (code
<< 8) | c
;
4793 CODING_DECODE_CHAR (coding
, src
, src_base
, src_end
,
4798 /* VAL is a list of charset IDs. It is assured that the
4799 list is sorted by charset dimensions (smaller one
4803 charset
= CHARSET_FROM_ID (XFASTINT (XCAR (val
)));
4804 dim
= CHARSET_DIMENSION (charset
);
4808 code
= (code
<< 8) | c
;
4811 CODING_DECODE_CHAR (coding
, src
, src_base
,
4812 src_end
, charset
, code
, c
);
4820 if (charset
->id
!= charset_ascii
4821 && last_id
!= charset
->id
)
4823 if (last_id
!= charset_ascii
)
4824 ADD_CHARSET_DATA (charbuf
, char_offset
- last_offset
, last_id
);
4825 last_id
= charset
->id
;
4826 last_offset
= char_offset
;
4835 consumed_chars
= consumed_chars_base
;
4837 *charbuf
++ = c
< 0 ? -c
: ASCII_BYTE_P (c
) ? c
: BYTE8_TO_CHAR (c
);
4843 if (last_id
!= charset_ascii
)
4844 ADD_CHARSET_DATA (charbuf
, char_offset
- last_offset
, last_id
);
4845 coding
->consumed_char
+= consumed_chars_base
;
4846 coding
->consumed
= src_base
- coding
->source
;
4847 coding
->charbuf_used
= charbuf
- coding
->charbuf
;
4851 encode_coding_charset (coding
)
4852 struct coding_system
*coding
;
4854 int multibytep
= coding
->dst_multibyte
;
4855 int *charbuf
= coding
->charbuf
;
4856 int *charbuf_end
= charbuf
+ coding
->charbuf_used
;
4857 unsigned char *dst
= coding
->destination
+ coding
->produced
;
4858 unsigned char *dst_end
= coding
->destination
+ coding
->dst_bytes
;
4859 int safe_room
= MAX_MULTIBYTE_LENGTH
;
4860 int produced_chars
= 0;
4861 Lisp_Object attrs
, charset_list
;
4862 int ascii_compatible
;
4865 CODING_GET_INFO (coding
, attrs
, charset_list
);
4866 ascii_compatible
= ! NILP (CODING_ATTR_ASCII_COMPAT (attrs
));
4868 while (charbuf
< charbuf_end
)
4870 struct charset
*charset
;
4873 ASSURE_DESTINATION (safe_room
);
4875 if (ascii_compatible
&& ASCII_CHAR_P (c
))
4876 EMIT_ONE_ASCII_BYTE (c
);
4877 else if (CHAR_BYTE8_P (c
))
4879 c
= CHAR_TO_BYTE8 (c
);
4884 charset
= char_charset (c
, charset_list
, &code
);
4887 if (CHARSET_DIMENSION (charset
) == 1)
4888 EMIT_ONE_BYTE (code
);
4889 else if (CHARSET_DIMENSION (charset
) == 2)
4890 EMIT_TWO_BYTES (code
>> 8, code
& 0xFF);
4891 else if (CHARSET_DIMENSION (charset
) == 3)
4892 EMIT_THREE_BYTES (code
>> 16, (code
>> 8) & 0xFF, code
& 0xFF);
4894 EMIT_FOUR_BYTES (code
>> 24, (code
>> 16) & 0xFF,
4895 (code
>> 8) & 0xFF, code
& 0xFF);
4899 if (coding
->mode
& CODING_MODE_SAFE_ENCODING
)
4900 c
= CODING_INHIBIT_CHARACTER_SUBSTITUTION
;
4902 c
= coding
->default_char
;
4908 record_conversion_result (coding
, CODING_RESULT_SUCCESS
);
4909 coding
->produced_char
+= produced_chars
;
4910 coding
->produced
= dst
- coding
->destination
;
4915 /*** 7. C library functions ***/
4917 /* Setup coding context CODING from information about CODING_SYSTEM.
4918 If CODING_SYSTEM is nil, `no-conversion' is assumed. If
4919 CODING_SYSTEM is invalid, signal an error. */
4922 setup_coding_system (coding_system
, coding
)
4923 Lisp_Object coding_system
;
4924 struct coding_system
*coding
;
4927 Lisp_Object eol_type
;
4928 Lisp_Object coding_type
;
4931 if (NILP (coding_system
))
4932 coding_system
= Qundecided
;
4934 CHECK_CODING_SYSTEM_GET_ID (coding_system
, coding
->id
);
4936 attrs
= CODING_ID_ATTRS (coding
->id
);
4937 eol_type
= CODING_ID_EOL_TYPE (coding
->id
);
4940 coding
->head_ascii
= -1;
4941 coding
->common_flags
4942 = (VECTORP (eol_type
) ? CODING_REQUIRE_DETECTION_MASK
: 0);
4943 if (! NILP (CODING_ATTR_POST_READ (attrs
)))
4944 coding
->common_flags
|= CODING_REQUIRE_DECODING_MASK
;
4945 if (! NILP (CODING_ATTR_PRE_WRITE (attrs
)))
4946 coding
->common_flags
|= CODING_REQUIRE_ENCODING_MASK
;
4947 if (! NILP (CODING_ATTR_FOR_UNIBYTE (attrs
)))
4948 coding
->common_flags
|= CODING_FOR_UNIBYTE_MASK
;
4950 val
= CODING_ATTR_SAFE_CHARSETS (attrs
);
4951 coding
->max_charset_id
= SCHARS (val
) - 1;
4952 coding
->safe_charsets
= (char *) SDATA (val
);
4953 coding
->default_char
= XINT (CODING_ATTR_DEFAULT_CHAR (attrs
));
4955 coding_type
= CODING_ATTR_TYPE (attrs
);
4956 if (EQ (coding_type
, Qundecided
))
4958 coding
->detector
= NULL
;
4959 coding
->decoder
= decode_coding_raw_text
;
4960 coding
->encoder
= encode_coding_raw_text
;
4961 coding
->common_flags
|= CODING_REQUIRE_DETECTION_MASK
;
4963 else if (EQ (coding_type
, Qiso_2022
))
4966 int flags
= XINT (AREF (attrs
, coding_attr_iso_flags
));
4968 /* Invoke graphic register 0 to plane 0. */
4969 CODING_ISO_INVOCATION (coding
, 0) = 0;
4970 /* Invoke graphic register 1 to plane 1 if we can use 8-bit. */
4971 CODING_ISO_INVOCATION (coding
, 1)
4972 = (flags
& CODING_ISO_FLAG_SEVEN_BITS
? -1 : 1);
4973 /* Setup the initial status of designation. */
4974 for (i
= 0; i
< 4; i
++)
4975 CODING_ISO_DESIGNATION (coding
, i
) = CODING_ISO_INITIAL (coding
, i
);
4976 /* Not single shifting initially. */
4977 CODING_ISO_SINGLE_SHIFTING (coding
) = 0;
4978 /* Beginning of buffer should also be regarded as bol. */
4979 CODING_ISO_BOL (coding
) = 1;
4980 coding
->detector
= detect_coding_iso_2022
;
4981 coding
->decoder
= decode_coding_iso_2022
;
4982 coding
->encoder
= encode_coding_iso_2022
;
4983 if (flags
& CODING_ISO_FLAG_SAFE
)
4984 coding
->mode
|= CODING_MODE_SAFE_ENCODING
;
4985 coding
->common_flags
4986 |= (CODING_REQUIRE_DECODING_MASK
| CODING_REQUIRE_ENCODING_MASK
4987 | CODING_REQUIRE_FLUSHING_MASK
);
4988 if (flags
& CODING_ISO_FLAG_COMPOSITION
)
4989 coding
->common_flags
|= CODING_ANNOTATE_COMPOSITION_MASK
;
4990 if (flags
& CODING_ISO_FLAG_DESIGNATION
)
4991 coding
->common_flags
|= CODING_ANNOTATE_CHARSET_MASK
;
4992 if (flags
& CODING_ISO_FLAG_FULL_SUPPORT
)
4994 setup_iso_safe_charsets (attrs
);
4995 val
= CODING_ATTR_SAFE_CHARSETS (attrs
);
4996 coding
->max_charset_id
= SCHARS (val
) - 1;
4997 coding
->safe_charsets
= (char *) SDATA (val
);
4999 CODING_ISO_FLAGS (coding
) = flags
;
5001 else if (EQ (coding_type
, Qcharset
))
5003 coding
->detector
= detect_coding_charset
;
5004 coding
->decoder
= decode_coding_charset
;
5005 coding
->encoder
= encode_coding_charset
;
5006 coding
->common_flags
5007 |= (CODING_REQUIRE_DECODING_MASK
| CODING_REQUIRE_ENCODING_MASK
);
5009 else if (EQ (coding_type
, Qutf_8
))
5011 coding
->detector
= detect_coding_utf_8
;
5012 coding
->decoder
= decode_coding_utf_8
;
5013 coding
->encoder
= encode_coding_utf_8
;
5014 coding
->common_flags
5015 |= (CODING_REQUIRE_DECODING_MASK
| CODING_REQUIRE_ENCODING_MASK
);
5017 else if (EQ (coding_type
, Qutf_16
))
5019 val
= AREF (attrs
, coding_attr_utf_16_bom
);
5020 CODING_UTF_16_BOM (coding
) = (CONSP (val
) ? utf_16_detect_bom
5021 : EQ (val
, Qt
) ? utf_16_with_bom
5022 : utf_16_without_bom
);
5023 val
= AREF (attrs
, coding_attr_utf_16_endian
);
5024 CODING_UTF_16_ENDIAN (coding
) = (EQ (val
, Qbig
) ? utf_16_big_endian
5025 : utf_16_little_endian
);
5026 CODING_UTF_16_SURROGATE (coding
) = 0;
5027 coding
->detector
= detect_coding_utf_16
;
5028 coding
->decoder
= decode_coding_utf_16
;
5029 coding
->encoder
= encode_coding_utf_16
;
5030 coding
->common_flags
5031 |= (CODING_REQUIRE_DECODING_MASK
| CODING_REQUIRE_ENCODING_MASK
);
5032 if (CODING_UTF_16_BOM (coding
) == utf_16_detect_bom
)
5033 coding
->common_flags
|= CODING_REQUIRE_DETECTION_MASK
;
5035 else if (EQ (coding_type
, Qccl
))
5037 coding
->detector
= detect_coding_ccl
;
5038 coding
->decoder
= decode_coding_ccl
;
5039 coding
->encoder
= encode_coding_ccl
;
5040 coding
->common_flags
5041 |= (CODING_REQUIRE_DECODING_MASK
| CODING_REQUIRE_ENCODING_MASK
5042 | CODING_REQUIRE_FLUSHING_MASK
);
5044 else if (EQ (coding_type
, Qemacs_mule
))
5046 coding
->detector
= detect_coding_emacs_mule
;
5047 coding
->decoder
= decode_coding_emacs_mule
;
5048 coding
->encoder
= encode_coding_emacs_mule
;
5049 coding
->common_flags
5050 |= (CODING_REQUIRE_DECODING_MASK
| CODING_REQUIRE_ENCODING_MASK
);
5051 if (! NILP (AREF (attrs
, coding_attr_emacs_mule_full
))
5052 && ! EQ (CODING_ATTR_CHARSET_LIST (attrs
), Vemacs_mule_charset_list
))
5054 Lisp_Object tail
, safe_charsets
;
5055 int max_charset_id
= 0;
5057 for (tail
= Vemacs_mule_charset_list
; CONSP (tail
);
5059 if (max_charset_id
< XFASTINT (XCAR (tail
)))
5060 max_charset_id
= XFASTINT (XCAR (tail
));
5061 safe_charsets
= Fmake_string (make_number (max_charset_id
+ 1),
5063 for (tail
= Vemacs_mule_charset_list
; CONSP (tail
);
5065 SSET (safe_charsets
, XFASTINT (XCAR (tail
)), 0);
5066 coding
->max_charset_id
= max_charset_id
;
5067 coding
->safe_charsets
= (char *) SDATA (safe_charsets
);
5070 else if (EQ (coding_type
, Qshift_jis
))
5072 coding
->detector
= detect_coding_sjis
;
5073 coding
->decoder
= decode_coding_sjis
;
5074 coding
->encoder
= encode_coding_sjis
;
5075 coding
->common_flags
5076 |= (CODING_REQUIRE_DECODING_MASK
| CODING_REQUIRE_ENCODING_MASK
);
5078 else if (EQ (coding_type
, Qbig5
))
5080 coding
->detector
= detect_coding_big5
;
5081 coding
->decoder
= decode_coding_big5
;
5082 coding
->encoder
= encode_coding_big5
;
5083 coding
->common_flags
5084 |= (CODING_REQUIRE_DECODING_MASK
| CODING_REQUIRE_ENCODING_MASK
);
5086 else /* EQ (coding_type, Qraw_text) */
5088 coding
->detector
= NULL
;
5089 coding
->decoder
= decode_coding_raw_text
;
5090 coding
->encoder
= encode_coding_raw_text
;
5091 if (! EQ (eol_type
, Qunix
))
5093 coding
->common_flags
|= CODING_REQUIRE_DECODING_MASK
;
5094 if (! VECTORP (eol_type
))
5095 coding
->common_flags
|= CODING_REQUIRE_ENCODING_MASK
;
5103 /* Return a list of charsets supported by CODING. */
5106 coding_charset_list (coding
)
5107 struct coding_system
*coding
;
5109 Lisp_Object attrs
, charset_list
;
5111 CODING_GET_INFO (coding
, attrs
, charset_list
);
5112 if (EQ (CODING_ATTR_TYPE (attrs
), Qiso_2022
))
5114 int flags
= XINT (AREF (attrs
, coding_attr_iso_flags
));
5116 if (flags
& CODING_ISO_FLAG_FULL_SUPPORT
)
5117 charset_list
= Viso_2022_charset_list
;
5119 else if (EQ (CODING_ATTR_TYPE (attrs
), Qemacs_mule
))
5121 charset_list
= Vemacs_mule_charset_list
;
5123 return charset_list
;
5127 /* Return raw-text or one of its subsidiaries that has the same
5128 eol_type as CODING-SYSTEM. */
5131 raw_text_coding_system (coding_system
)
5132 Lisp_Object coding_system
;
5134 Lisp_Object spec
, attrs
;
5135 Lisp_Object eol_type
, raw_text_eol_type
;
5137 if (NILP (coding_system
))
5139 spec
= CODING_SYSTEM_SPEC (coding_system
);
5140 attrs
= AREF (spec
, 0);
5142 if (EQ (CODING_ATTR_TYPE (attrs
), Qraw_text
))
5143 return coding_system
;
5145 eol_type
= AREF (spec
, 2);
5146 if (VECTORP (eol_type
))
5148 spec
= CODING_SYSTEM_SPEC (Qraw_text
);
5149 raw_text_eol_type
= AREF (spec
, 2);
5150 return (EQ (eol_type
, Qunix
) ? AREF (raw_text_eol_type
, 0)
5151 : EQ (eol_type
, Qdos
) ? AREF (raw_text_eol_type
, 1)
5152 : AREF (raw_text_eol_type
, 2));
5156 /* If CODING_SYSTEM doesn't specify end-of-line format but PARENT
5157 does, return one of the subsidiary that has the same eol-spec as
5158 PARENT. Otherwise, return CODING_SYSTEM. */
5161 coding_inherit_eol_type (coding_system
, parent
)
5162 Lisp_Object coding_system
, parent
;
5164 Lisp_Object spec
, eol_type
;
5166 if (NILP (coding_system
))
5167 coding_system
= Qraw_text
;
5168 spec
= CODING_SYSTEM_SPEC (coding_system
);
5169 eol_type
= AREF (spec
, 2);
5170 if (VECTORP (eol_type
)
5173 Lisp_Object parent_spec
;
5174 Lisp_Object parent_eol_type
;
5177 = CODING_SYSTEM_SPEC (buffer_defaults
.buffer_file_coding_system
);
5178 parent_eol_type
= AREF (parent_spec
, 2);
5179 if (EQ (parent_eol_type
, Qunix
))
5180 coding_system
= AREF (eol_type
, 0);
5181 else if (EQ (parent_eol_type
, Qdos
))
5182 coding_system
= AREF (eol_type
, 1);
5183 else if (EQ (parent_eol_type
, Qmac
))
5184 coding_system
= AREF (eol_type
, 2);
5186 return coding_system
;
5189 /* Emacs has a mechanism to automatically detect a coding system if it
5190 is one of Emacs' internal format, ISO2022, SJIS, and BIG5. But,
5191 it's impossible to distinguish some coding systems accurately
5192 because they use the same range of codes. So, at first, coding
5193 systems are categorized into 7, those are:
5195 o coding-category-emacs-mule
5197 The category for a coding system which has the same code range
5198 as Emacs' internal format. Assigned the coding-system (Lisp
5199 symbol) `emacs-mule' by default.
5201 o coding-category-sjis
5203 The category for a coding system which has the same code range
5204 as SJIS. Assigned the coding-system (Lisp
5205 symbol) `japanese-shift-jis' by default.
5207 o coding-category-iso-7
5209 The category for a coding system which has the same code range
5210 as ISO2022 of 7-bit environment. This doesn't use any locking
5211 shift and single shift functions. This can encode/decode all
5212 charsets. Assigned the coding-system (Lisp symbol)
5213 `iso-2022-7bit' by default.
5215 o coding-category-iso-7-tight
5217 Same as coding-category-iso-7 except that this can
5218 encode/decode only the specified charsets.
5220 o coding-category-iso-8-1
5222 The category for a coding system which has the same code range
5223 as ISO2022 of 8-bit environment and graphic plane 1 used only
5224 for DIMENSION1 charset. This doesn't use any locking shift
5225 and single shift functions. Assigned the coding-system (Lisp
5226 symbol) `iso-latin-1' by default.
5228 o coding-category-iso-8-2
5230 The category for a coding system which has the same code range
5231 as ISO2022 of 8-bit environment and graphic plane 1 used only
5232 for DIMENSION2 charset. This doesn't use any locking shift
5233 and single shift functions. Assigned the coding-system (Lisp
5234 symbol) `japanese-iso-8bit' by default.
5236 o coding-category-iso-7-else
5238 The category for a coding system which has the same code range
5239 as ISO2022 of 7-bit environemnt but uses locking shift or
5240 single shift functions. Assigned the coding-system (Lisp
5241 symbol) `iso-2022-7bit-lock' by default.
5243 o coding-category-iso-8-else
5245 The category for a coding system which has the same code range
5246 as ISO2022 of 8-bit environemnt but uses locking shift or
5247 single shift functions. Assigned the coding-system (Lisp
5248 symbol) `iso-2022-8bit-ss2' by default.
5250 o coding-category-big5
5252 The category for a coding system which has the same code range
5253 as BIG5. Assigned the coding-system (Lisp symbol)
5254 `cn-big5' by default.
5256 o coding-category-utf-8
5258 The category for a coding system which has the same code range
5259 as UTF-8 (cf. RFC3629). Assigned the coding-system (Lisp
5260 symbol) `utf-8' by default.
5262 o coding-category-utf-16-be
5264 The category for a coding system in which a text has an
5265 Unicode signature (cf. Unicode Standard) in the order of BIG
5266 endian at the head. Assigned the coding-system (Lisp symbol)
5267 `utf-16-be' by default.
5269 o coding-category-utf-16-le
5271 The category for a coding system in which a text has an
5272 Unicode signature (cf. Unicode Standard) in the order of
5273 LITTLE endian at the head. Assigned the coding-system (Lisp
5274 symbol) `utf-16-le' by default.
5276 o coding-category-ccl
5278 The category for a coding system of which encoder/decoder is
5279 written in CCL programs. The default value is nil, i.e., no
5280 coding system is assigned.
5282 o coding-category-binary
5284 The category for a coding system not categorized in any of the
5285 above. Assigned the coding-system (Lisp symbol)
5286 `no-conversion' by default.
5288 Each of them is a Lisp symbol and the value is an actual
5289 `coding-system's (this is also a Lisp symbol) assigned by a user.
5290 What Emacs does actually is to detect a category of coding system.
5291 Then, it uses a `coding-system' assigned to it. If Emacs can't
5292 decide only one possible category, it selects a category of the
5293 highest priority. Priorities of categories are also specified by a
5294 user in a Lisp variable `coding-category-list'.
5298 #define EOL_SEEN_NONE 0
5299 #define EOL_SEEN_LF 1
5300 #define EOL_SEEN_CR 2
5301 #define EOL_SEEN_CRLF 4
5303 /* Detect how end-of-line of a text of length SRC_BYTES pointed by
5304 SOURCE is encoded. If CATEGORY is one of
5305 coding_category_utf_16_XXXX, assume that CR and LF are encoded by
5306 two-byte, else they are encoded by one-byte.
5308 Return one of EOL_SEEN_XXX. */
5310 #define MAX_EOL_CHECK_COUNT 3
5313 detect_eol (source
, src_bytes
, category
)
5314 const unsigned char *source
;
5315 EMACS_INT src_bytes
;
5316 enum coding_category category
;
5318 const unsigned char *src
= source
, *src_end
= src
+ src_bytes
;
5321 int eol_seen
= EOL_SEEN_NONE
;
5323 if ((1 << category
) & CATEGORY_MASK_UTF_16
)
5327 msb
= category
== (coding_category_utf_16_le
5328 | coding_category_utf_16_le_nosig
);
5331 while (src
+ 1 < src_end
)
5334 if (src
[msb
] == 0 && (c
== '\n' || c
== '\r'))
5339 this_eol
= EOL_SEEN_LF
;
5340 else if (src
+ 3 >= src_end
5341 || src
[msb
+ 2] != 0
5342 || src
[lsb
+ 2] != '\n')
5343 this_eol
= EOL_SEEN_CR
;
5345 this_eol
= EOL_SEEN_CRLF
;
5347 if (eol_seen
== EOL_SEEN_NONE
)
5348 /* This is the first end-of-line. */
5349 eol_seen
= this_eol
;
5350 else if (eol_seen
!= this_eol
)
5352 /* The found type is different from what found before. */
5353 eol_seen
= EOL_SEEN_LF
;
5356 if (++total
== MAX_EOL_CHECK_COUNT
)
5364 while (src
< src_end
)
5367 if (c
== '\n' || c
== '\r')
5372 this_eol
= EOL_SEEN_LF
;
5373 else if (src
>= src_end
|| *src
!= '\n')
5374 this_eol
= EOL_SEEN_CR
;
5376 this_eol
= EOL_SEEN_CRLF
, src
++;
5378 if (eol_seen
== EOL_SEEN_NONE
)
5379 /* This is the first end-of-line. */
5380 eol_seen
= this_eol
;
5381 else if (eol_seen
!= this_eol
)
5383 /* The found type is different from what found before. */
5384 eol_seen
= EOL_SEEN_LF
;
5387 if (++total
== MAX_EOL_CHECK_COUNT
)
5397 adjust_coding_eol_type (coding
, eol_seen
)
5398 struct coding_system
*coding
;
5401 Lisp_Object eol_type
;
5403 eol_type
= CODING_ID_EOL_TYPE (coding
->id
);
5404 if (eol_seen
& EOL_SEEN_LF
)
5406 coding
->id
= CODING_SYSTEM_ID (AREF (eol_type
, 0));
5409 else if (eol_seen
& EOL_SEEN_CRLF
)
5411 coding
->id
= CODING_SYSTEM_ID (AREF (eol_type
, 1));
5414 else if (eol_seen
& EOL_SEEN_CR
)
5416 coding
->id
= CODING_SYSTEM_ID (AREF (eol_type
, 2));
5422 /* Detect how a text specified in CODING is encoded. If a coding
5423 system is detected, update fields of CODING by the detected coding
5427 detect_coding (coding
)
5428 struct coding_system
*coding
;
5430 const unsigned char *src
, *src_end
;
5432 coding
->consumed
= coding
->consumed_char
= 0;
5433 coding
->produced
= coding
->produced_char
= 0;
5434 coding_set_source (coding
);
5436 src_end
= coding
->source
+ coding
->src_bytes
;
5438 /* If we have not yet decided the text encoding type, detect it
5440 if (EQ (CODING_ATTR_TYPE (CODING_ID_ATTRS (coding
->id
)), Qundecided
))
5443 struct coding_detection_info detect_info
;
5445 detect_info
.checked
= detect_info
.found
= detect_info
.rejected
= 0;
5446 for (i
= 0, src
= coding
->source
; src
< src_end
; i
++, src
++)
5452 && (c
== ISO_CODE_ESC
|| c
== ISO_CODE_SI
|| c
== ISO_CODE_SO
)
5453 && ! inhibit_iso_escape_detection
5454 && ! detect_info
.checked
)
5456 coding
->head_ascii
= src
- (coding
->source
+ coding
->consumed
);
5457 if (detect_coding_iso_2022 (coding
, &detect_info
))
5459 /* We have scanned the whole data. */
5460 if (! (detect_info
.rejected
& CATEGORY_MASK_ISO_7_ELSE
))
5461 /* We didn't find an 8-bit code. */
5467 coding
->head_ascii
= src
- (coding
->source
+ coding
->consumed
);
5469 if (coding
->head_ascii
< coding
->src_bytes
5470 || detect_info
.found
)
5472 enum coding_category category
;
5473 struct coding_system
*this;
5475 if (coding
->head_ascii
== coding
->src_bytes
)
5476 /* As all bytes are 7-bit, we can ignore non-ISO-2022 codings. */
5477 for (i
= 0; i
< coding_category_raw_text
; i
++)
5479 category
= coding_priorities
[i
];
5480 this = coding_categories
+ category
;
5481 if (detect_info
.found
& (1 << category
))
5485 for (i
= 0; i
< coding_category_raw_text
; i
++)
5487 category
= coding_priorities
[i
];
5488 this = coding_categories
+ category
;
5491 /* No coding system of this category is defined. */
5492 detect_info
.rejected
|= (1 << category
);
5494 else if (category
>= coding_category_raw_text
)
5496 else if (detect_info
.checked
& (1 << category
))
5498 if (detect_info
.found
& (1 << category
))
5501 else if ((*(this->detector
)) (coding
, &detect_info
)
5502 && detect_info
.found
& (1 << category
))
5504 if (category
== coding_category_utf_16_auto
)
5506 if (detect_info
.found
& CATEGORY_MASK_UTF_16_LE
)
5507 category
= coding_category_utf_16_le
;
5509 category
= coding_category_utf_16_be
;
5515 if (i
< coding_category_raw_text
)
5516 setup_coding_system (CODING_ID_NAME (this->id
), coding
);
5517 else if (detect_info
.rejected
== CATEGORY_MASK_ANY
)
5518 setup_coding_system (Qraw_text
, coding
);
5519 else if (detect_info
.rejected
)
5520 for (i
= 0; i
< coding_category_raw_text
; i
++)
5521 if (! (detect_info
.rejected
& (1 << coding_priorities
[i
])))
5523 this = coding_categories
+ coding_priorities
[i
];
5524 setup_coding_system (CODING_ID_NAME (this->id
), coding
);
5529 else if (XINT (CODING_ATTR_CATEGORY (CODING_ID_ATTRS (coding
->id
)))
5530 == coding_category_utf_16_auto
)
5532 Lisp_Object coding_systems
;
5533 struct coding_detection_info detect_info
;
5536 = AREF (CODING_ID_ATTRS (coding
->id
), coding_attr_utf_16_bom
);
5537 detect_info
.found
= detect_info
.rejected
= 0;
5538 if (CONSP (coding_systems
)
5539 && detect_coding_utf_16 (coding
, &detect_info
))
5541 if (detect_info
.found
& CATEGORY_MASK_UTF_16_LE
)
5542 setup_coding_system (XCAR (coding_systems
), coding
);
5543 else if (detect_info
.found
& CATEGORY_MASK_UTF_16_BE
)
5544 setup_coding_system (XCDR (coding_systems
), coding
);
5552 struct coding_system
*coding
;
5554 Lisp_Object eol_type
;
5555 unsigned char *p
, *pbeg
, *pend
;
5557 eol_type
= CODING_ID_EOL_TYPE (coding
->id
);
5558 if (EQ (eol_type
, Qunix
))
5561 if (NILP (coding
->dst_object
))
5562 pbeg
= coding
->destination
;
5564 pbeg
= BYTE_POS_ADDR (coding
->dst_pos_byte
);
5565 pend
= pbeg
+ coding
->produced
;
5567 if (VECTORP (eol_type
))
5569 int eol_seen
= EOL_SEEN_NONE
;
5571 for (p
= pbeg
; p
< pend
; p
++)
5574 eol_seen
|= EOL_SEEN_LF
;
5575 else if (*p
== '\r')
5577 if (p
+ 1 < pend
&& *(p
+ 1) == '\n')
5579 eol_seen
|= EOL_SEEN_CRLF
;
5583 eol_seen
|= EOL_SEEN_CR
;
5586 if (eol_seen
!= EOL_SEEN_NONE
5587 && eol_seen
!= EOL_SEEN_LF
5588 && eol_seen
!= EOL_SEEN_CRLF
5589 && eol_seen
!= EOL_SEEN_CR
)
5590 eol_seen
= EOL_SEEN_LF
;
5591 if (eol_seen
!= EOL_SEEN_NONE
)
5592 eol_type
= adjust_coding_eol_type (coding
, eol_seen
);
5595 if (EQ (eol_type
, Qmac
))
5597 for (p
= pbeg
; p
< pend
; p
++)
5601 else if (EQ (eol_type
, Qdos
))
5605 if (NILP (coding
->dst_object
))
5607 for (p
= pend
- 2; p
>= pbeg
; p
--)
5610 safe_bcopy ((char *) (p
+ 1), (char *) p
, pend
-- - p
- 1);
5616 for (p
= pend
- 2; p
>= pbeg
; p
--)
5619 int pos_byte
= coding
->dst_pos_byte
+ (p
- pbeg
);
5620 int pos
= BYTE_TO_CHAR (pos_byte
);
5622 del_range_2 (pos
, pos_byte
, pos
+ 1, pos_byte
+ 1, 0);
5626 coding
->produced
-= n
;
5627 coding
->produced_char
-= n
;
5632 /* Return a translation table (or list of them) from coding system
5633 attribute vector ATTRS for encoding (ENCODEP is nonzero) or
5634 decoding (ENCODEP is zero). */
5637 get_translation_table (attrs
, encodep
, max_lookup
)
5639 int encodep
, *max_lookup
;
5641 Lisp_Object standard
, translation_table
;
5645 translation_table
= CODING_ATTR_ENCODE_TBL (attrs
),
5646 standard
= Vstandard_translation_table_for_encode
;
5648 translation_table
= CODING_ATTR_DECODE_TBL (attrs
),
5649 standard
= Vstandard_translation_table_for_decode
;
5650 if (NILP (translation_table
))
5651 translation_table
= standard
;
5654 if (SYMBOLP (translation_table
))
5655 translation_table
= Fget (translation_table
, Qtranslation_table
);
5656 else if (CONSP (translation_table
))
5658 translation_table
= Fcopy_sequence (translation_table
);
5659 for (val
= translation_table
; CONSP (val
); val
= XCDR (val
))
5660 if (SYMBOLP (XCAR (val
)))
5661 XSETCAR (val
, Fget (XCAR (val
), Qtranslation_table
));
5663 if (CHAR_TABLE_P (standard
))
5665 if (CONSP (translation_table
))
5666 translation_table
= nconc2 (translation_table
,
5667 Fcons (standard
, Qnil
));
5669 translation_table
= Fcons (translation_table
,
5670 Fcons (standard
, Qnil
));
5677 if (CHAR_TABLE_P (translation_table
)
5678 && CHAR_TABLE_EXTRA_SLOTS (XCHAR_TABLE (translation_table
)) > 1)
5680 val
= XCHAR_TABLE (translation_table
)->extras
[1];
5681 if (NATNUMP (val
) && *max_lookup
< XFASTINT (val
))
5682 *max_lookup
= XFASTINT (val
);
5684 else if (CONSP (translation_table
))
5686 Lisp_Object tail
, val
;
5688 for (tail
= translation_table
; CONSP (tail
); tail
= XCDR (tail
))
5689 if (CHAR_TABLE_P (XCAR (tail
))
5690 && CHAR_TABLE_EXTRA_SLOTS (XCHAR_TABLE (XCAR (tail
))) > 1)
5692 val
= XCHAR_TABLE (XCAR (tail
))->extras
[1];
5693 if (NATNUMP (val
) && *max_lookup
< XFASTINT (val
))
5694 *max_lookup
= XFASTINT (val
);
5698 return translation_table
;
5701 #define LOOKUP_TRANSLATION_TABLE(table, c, trans) \
5704 if (CHAR_TABLE_P (table)) \
5706 trans = CHAR_TABLE_REF (table, c); \
5707 if (CHARACTERP (trans)) \
5708 c = XFASTINT (trans), trans = Qnil; \
5710 else if (CONSP (table)) \
5714 for (tail = table; CONSP (tail); tail = XCDR (tail)) \
5715 if (CHAR_TABLE_P (XCAR (tail))) \
5717 trans = CHAR_TABLE_REF (XCAR (tail), c); \
5718 if (CHARACTERP (trans)) \
5719 c = XFASTINT (trans), trans = Qnil; \
5720 else if (! NILP (trans)) \
5728 get_translation (val
, buf
, buf_end
, last_block
, from_nchars
, to_nchars
)
5732 int *from_nchars
, *to_nchars
;
5734 /* VAL is TO or (([FROM-CHAR ...] . TO) ...) where TO is TO-CHAR or
5738 Lisp_Object from
, tail
;
5741 for (tail
= val
; CONSP (tail
); tail
= XCDR (tail
))
5746 for (i
= 0; i
< len
; i
++)
5748 if (buf
+ i
== buf_end
)
5754 if (XINT (AREF (from
, i
)) != buf
[i
])
5768 *buf
= XINT (AREF (val
, 0)), *to_nchars
= ASIZE (val
);
5776 produce_chars (coding
, translation_table
, last_block
)
5777 struct coding_system
*coding
;
5778 Lisp_Object translation_table
;
5781 unsigned char *dst
= coding
->destination
+ coding
->produced
;
5782 unsigned char *dst_end
= coding
->destination
+ coding
->dst_bytes
;
5784 int produced_chars
= 0;
5787 if (! coding
->chars_at_source
)
5789 /* Characters are in coding->charbuf. */
5790 int *buf
= coding
->charbuf
;
5791 int *buf_end
= buf
+ coding
->charbuf_used
;
5793 if (BUFFERP (coding
->src_object
)
5794 && EQ (coding
->src_object
, coding
->dst_object
))
5795 dst_end
= ((unsigned char *) coding
->source
) + coding
->consumed
;
5797 while (buf
< buf_end
)
5803 int from_nchars
= 1, to_nchars
= 1;
5804 Lisp_Object trans
= Qnil
;
5806 LOOKUP_TRANSLATION_TABLE (translation_table
, c
, trans
);
5809 trans
= get_translation (trans
, buf
, buf_end
, last_block
,
5810 &from_nchars
, &to_nchars
);
5816 if (dst
+ MAX_MULTIBYTE_LENGTH
* to_nchars
> dst_end
)
5818 dst
= alloc_destination (coding
,
5820 + MAX_MULTIBYTE_LENGTH
* to_nchars
,
5822 dst_end
= coding
->destination
+ coding
->dst_bytes
;
5825 for (i
= 0; i
< to_nchars
; i
++)
5828 c
= XINT (AREF (trans
, i
));
5829 if (coding
->dst_multibyte
5830 || ! CHAR_BYTE8_P (c
))
5831 CHAR_STRING_ADVANCE (c
, dst
);
5833 *dst
++ = CHAR_TO_BYTE8 (c
);
5835 produced_chars
+= to_nchars
;
5837 while (--from_nchars
> 0)
5841 /* This is an annotation datum. (-C) is the length. */
5844 carryover
= buf_end
- buf
;
5848 const unsigned char *src
= coding
->source
;
5849 const unsigned char *src_end
= src
+ coding
->src_bytes
;
5850 Lisp_Object eol_type
;
5852 eol_type
= CODING_ID_EOL_TYPE (coding
->id
);
5854 if (coding
->src_multibyte
!= coding
->dst_multibyte
)
5856 if (coding
->src_multibyte
)
5863 const unsigned char *src_base
= src
;
5869 if (EQ (eol_type
, Qdos
))
5873 record_conversion_result
5874 (coding
, CODING_RESULT_INSUFFICIENT_SRC
);
5875 goto no_more_source
;
5880 else if (EQ (eol_type
, Qmac
))
5885 coding
->consumed
= src
- coding
->source
;
5887 if (EQ (coding
->src_object
, coding
->dst_object
))
5888 dst_end
= (unsigned char *) src
;
5891 dst
= alloc_destination (coding
, src_end
- src
+ 1,
5893 dst_end
= coding
->destination
+ coding
->dst_bytes
;
5894 coding_set_source (coding
);
5895 src
= coding
->source
+ coding
->consumed
;
5896 src_end
= coding
->source
+ coding
->src_bytes
;
5906 while (src
< src_end
)
5913 if (EQ (eol_type
, Qdos
))
5919 else if (EQ (eol_type
, Qmac
))
5922 if (dst
>= dst_end
- 1)
5924 coding
->consumed
= src
- coding
->source
;
5926 if (EQ (coding
->src_object
, coding
->dst_object
))
5927 dst_end
= (unsigned char *) src
;
5928 if (dst
>= dst_end
- 1)
5930 dst
= alloc_destination (coding
, src_end
- src
+ 2,
5932 dst_end
= coding
->destination
+ coding
->dst_bytes
;
5933 coding_set_source (coding
);
5934 src
= coding
->source
+ coding
->consumed
;
5935 src_end
= coding
->source
+ coding
->src_bytes
;
5943 if (!EQ (coding
->src_object
, coding
->dst_object
))
5945 int require
= coding
->src_bytes
- coding
->dst_bytes
;
5949 EMACS_INT offset
= src
- coding
->source
;
5951 dst
= alloc_destination (coding
, require
, dst
);
5952 coding_set_source (coding
);
5953 src
= coding
->source
+ offset
;
5954 src_end
= coding
->source
+ coding
->src_bytes
;
5957 produced_chars
= coding
->src_chars
;
5958 while (src
< src_end
)
5964 if (EQ (eol_type
, Qdos
))
5971 else if (EQ (eol_type
, Qmac
))
5977 coding
->consumed
= coding
->src_bytes
;
5978 coding
->consumed_char
= coding
->src_chars
;
5981 produced
= dst
- (coding
->destination
+ coding
->produced
);
5982 if (BUFFERP (coding
->dst_object
))
5983 insert_from_gap (produced_chars
, produced
);
5984 coding
->produced
+= produced
;
5985 coding
->produced_char
+= produced_chars
;
5989 /* Compose text in CODING->object according to the annotation data at
5990 CHARBUF. CHARBUF is an array:
5991 [ -LENGTH ANNOTATION_MASK FROM TO METHOD COMP_LEN [ COMPONENTS... ] ]
5995 produce_composition (coding
, charbuf
, pos
)
5996 struct coding_system
*coding
;
6002 enum composition_method method
;
6003 Lisp_Object components
;
6006 to
= pos
+ charbuf
[2];
6009 method
= (enum composition_method
) (charbuf
[3]);
6011 if (method
== COMPOSITION_RELATIVE
)
6013 else if (method
>= COMPOSITION_WITH_RULE
6014 && method
<= COMPOSITION_WITH_RULE_ALTCHARS
)
6016 Lisp_Object args
[MAX_COMPOSITION_COMPONENTS
* 2 - 1];
6021 for (i
= 0; i
< len
; i
++)
6023 args
[i
] = make_number (charbuf
[i
]);
6027 components
= (method
== COMPOSITION_WITH_ALTCHARS
6028 ? Fstring (len
, args
) : Fvector (len
, args
));
6032 compose_text (pos
, to
, components
, Qnil
, coding
->dst_object
);
6036 /* Put `charset' property on text in CODING->object according to
6037 the annotation data at CHARBUF. CHARBUF is an array:
6038 [ -LENGTH ANNOTATION_MASK NCHARS CHARSET-ID ]
6042 produce_charset (coding
, charbuf
, pos
)
6043 struct coding_system
*coding
;
6047 EMACS_INT from
= pos
- charbuf
[2];
6048 struct charset
*charset
= CHARSET_FROM_ID (charbuf
[3]);
6050 Fput_text_property (make_number (from
), make_number (pos
),
6051 Qcharset
, CHARSET_NAME (charset
),
6052 coding
->dst_object
);
6056 #define CHARBUF_SIZE 0x4000
6058 #define ALLOC_CONVERSION_WORK_AREA(coding) \
6060 int size = CHARBUF_SIZE;; \
6062 coding->charbuf = NULL; \
6063 while (size > 1024) \
6065 coding->charbuf = (int *) alloca (sizeof (int) * size); \
6066 if (coding->charbuf) \
6070 if (! coding->charbuf) \
6072 record_conversion_result (coding, CODING_RESULT_INSUFFICIENT_MEM); \
6073 return coding->result; \
6075 coding->charbuf_size = size; \
6080 produce_annotation (coding
, pos
)
6081 struct coding_system
*coding
;
6084 int *charbuf
= coding
->charbuf
;
6085 int *charbuf_end
= charbuf
+ coding
->charbuf_used
;
6087 if (NILP (coding
->dst_object
))
6090 while (charbuf
< charbuf_end
)
6096 int len
= -*charbuf
;
6099 case CODING_ANNOTATE_COMPOSITION_MASK
:
6100 produce_composition (coding
, charbuf
, pos
);
6102 case CODING_ANNOTATE_CHARSET_MASK
:
6103 produce_charset (coding
, charbuf
, pos
);
6113 /* Decode the data at CODING->src_object into CODING->dst_object.
6114 CODING->src_object is a buffer, a string, or nil.
6115 CODING->dst_object is a buffer.
6117 If CODING->src_object is a buffer, it must be the current buffer.
6118 In this case, if CODING->src_pos is positive, it is a position of
6119 the source text in the buffer, otherwise, the source text is in the
6120 gap area of the buffer, and CODING->src_pos specifies the offset of
6121 the text from GPT (which must be the same as PT). If this is the
6122 same buffer as CODING->dst_object, CODING->src_pos must be
6125 If CODING->src_object is a string, CODING->src_pos in an index to
6128 If CODING->src_object is nil, CODING->source must already point to
6129 the non-relocatable memory area. In this case, CODING->src_pos is
6130 an offset from CODING->source.
6132 The decoded data is inserted at the current point of the buffer
6137 decode_coding (coding
)
6138 struct coding_system
*coding
;
6141 Lisp_Object undo_list
;
6142 Lisp_Object translation_table
;
6146 if (BUFFERP (coding
->src_object
)
6147 && coding
->src_pos
> 0
6148 && coding
->src_pos
< GPT
6149 && coding
->src_pos
+ coding
->src_chars
> GPT
)
6150 move_gap_both (coding
->src_pos
, coding
->src_pos_byte
);
6153 if (BUFFERP (coding
->dst_object
))
6155 if (current_buffer
!= XBUFFER (coding
->dst_object
))
6156 set_buffer_internal (XBUFFER (coding
->dst_object
));
6158 move_gap_both (PT
, PT_BYTE
);
6159 undo_list
= current_buffer
->undo_list
;
6160 current_buffer
->undo_list
= Qt
;
6163 coding
->consumed
= coding
->consumed_char
= 0;
6164 coding
->produced
= coding
->produced_char
= 0;
6165 coding
->chars_at_source
= 0;
6166 record_conversion_result (coding
, CODING_RESULT_SUCCESS
);
6169 ALLOC_CONVERSION_WORK_AREA (coding
);
6171 attrs
= CODING_ID_ATTRS (coding
->id
);
6172 translation_table
= get_translation_table (attrs
, 0, NULL
);
6177 EMACS_INT pos
= coding
->dst_pos
+ coding
->produced_char
;
6179 coding_set_source (coding
);
6180 coding
->annotated
= 0;
6181 coding
->charbuf_used
= carryover
;
6182 (*(coding
->decoder
)) (coding
);
6183 coding_set_destination (coding
);
6184 carryover
= produce_chars (coding
, translation_table
, 0);
6185 if (coding
->annotated
)
6186 produce_annotation (coding
, pos
);
6187 for (i
= 0; i
< carryover
; i
++)
6189 = coding
->charbuf
[coding
->charbuf_used
- carryover
+ i
];
6191 while (coding
->consumed
< coding
->src_bytes
6192 && (coding
->result
== CODING_RESULT_SUCCESS
6193 || coding
->result
== CODING_RESULT_INVALID_SRC
));
6197 coding_set_destination (coding
);
6198 coding
->charbuf_used
= carryover
;
6199 produce_chars (coding
, translation_table
, 1);
6202 coding
->carryover_bytes
= 0;
6203 if (coding
->consumed
< coding
->src_bytes
)
6205 int nbytes
= coding
->src_bytes
- coding
->consumed
;
6206 const unsigned char *src
;
6208 coding_set_source (coding
);
6209 coding_set_destination (coding
);
6210 src
= coding
->source
+ coding
->consumed
;
6212 if (coding
->mode
& CODING_MODE_LAST_BLOCK
)
6214 /* Flush out unprocessed data as binary chars. We are sure
6215 that the number of data is less than the size of
6217 coding
->charbuf_used
= 0;
6218 while (nbytes
-- > 0)
6223 c
= BYTE8_TO_CHAR (c
);
6224 coding
->charbuf
[coding
->charbuf_used
++] = c
;
6226 produce_chars (coding
, Qnil
, 1);
6230 /* Record unprocessed bytes in coding->carryover. We are
6231 sure that the number of data is less than the size of
6232 coding->carryover. */
6233 unsigned char *p
= coding
->carryover
;
6235 coding
->carryover_bytes
= nbytes
;
6236 while (nbytes
-- > 0)
6239 coding
->consumed
= coding
->src_bytes
;
6242 if (BUFFERP (coding
->dst_object
))
6244 current_buffer
->undo_list
= undo_list
;
6245 record_insert (coding
->dst_pos
, coding
->produced_char
);
6247 if (! EQ (CODING_ID_EOL_TYPE (coding
->id
), Qunix
))
6248 decode_eol (coding
);
6249 return coding
->result
;
6253 /* Extract an annotation datum from a composition starting at POS and
6254 ending before LIMIT of CODING->src_object (buffer or string), store
6255 the data in BUF, set *STOP to a starting position of the next
6256 composition (if any) or to LIMIT, and return the address of the
6257 next element of BUF.
6259 If such an annotation is not found, set *STOP to a starting
6260 position of a composition after POS (if any) or to LIMIT, and
6264 handle_composition_annotation (pos
, limit
, coding
, buf
, stop
)
6265 EMACS_INT pos
, limit
;
6266 struct coding_system
*coding
;
6270 EMACS_INT start
, end
;
6273 if (! find_composition (pos
, limit
, &start
, &end
, &prop
, coding
->src_object
)
6276 else if (start
> pos
)
6282 /* We found a composition. Store the corresponding
6283 annotation data in BUF. */
6285 enum composition_method method
= COMPOSITION_METHOD (prop
);
6286 int nchars
= COMPOSITION_LENGTH (prop
);
6288 ADD_COMPOSITION_DATA (buf
, nchars
, method
);
6289 if (method
!= COMPOSITION_RELATIVE
)
6291 Lisp_Object components
;
6294 components
= COMPOSITION_COMPONENTS (prop
);
6295 if (VECTORP (components
))
6297 len
= XVECTOR (components
)->size
;
6298 for (i
= 0; i
< len
; i
++)
6299 *buf
++ = XINT (AREF (components
, i
));
6301 else if (STRINGP (components
))
6303 len
= SCHARS (components
);
6307 FETCH_STRING_CHAR_ADVANCE (*buf
, components
, i
, i_byte
);
6311 else if (INTEGERP (components
))
6314 *buf
++ = XINT (components
);
6316 else if (CONSP (components
))
6318 for (len
= 0; CONSP (components
);
6319 len
++, components
= XCDR (components
))
6320 *buf
++ = XINT (XCAR (components
));
6328 if (find_composition (end
, limit
, &start
, &end
, &prop
,
6339 /* Extract an annotation datum from a text property `charset' at POS of
6340 CODING->src_object (buffer of string), store the data in BUF, set
6341 *STOP to the position where the value of `charset' property changes
6342 (limiting by LIMIT), and return the address of the next element of
6345 If the property value is nil, set *STOP to the position where the
6346 property value is non-nil (limiting by LIMIT), and return BUF. */
6349 handle_charset_annotation (pos
, limit
, coding
, buf
, stop
)
6350 EMACS_INT pos
, limit
;
6351 struct coding_system
*coding
;
6355 Lisp_Object val
, next
;
6358 val
= Fget_text_property (make_number (pos
), Qcharset
, coding
->src_object
);
6359 if (! NILP (val
) && CHARSETP (val
))
6360 id
= XINT (CHARSET_SYMBOL_ID (val
));
6363 ADD_CHARSET_DATA (buf
, 0, id
);
6364 next
= Fnext_single_property_change (make_number (pos
), Qcharset
,
6366 make_number (limit
));
6367 *stop
= XINT (next
);
6373 consume_chars (coding
, translation_table
, max_lookup
)
6374 struct coding_system
*coding
;
6375 Lisp_Object translation_table
;
6378 int *buf
= coding
->charbuf
;
6379 int *buf_end
= coding
->charbuf
+ coding
->charbuf_size
;
6380 const unsigned char *src
= coding
->source
+ coding
->consumed
;
6381 const unsigned char *src_end
= coding
->source
+ coding
->src_bytes
;
6382 EMACS_INT pos
= coding
->src_pos
+ coding
->consumed_char
;
6383 EMACS_INT end_pos
= coding
->src_pos
+ coding
->src_chars
;
6384 int multibytep
= coding
->src_multibyte
;
6385 Lisp_Object eol_type
;
6387 EMACS_INT stop
, stop_composition
, stop_charset
;
6388 int *lookup_buf
= NULL
;
6390 if (! NILP (translation_table
))
6391 lookup_buf
= alloca (sizeof (int) * max_lookup
);
6393 eol_type
= CODING_ID_EOL_TYPE (coding
->id
);
6394 if (VECTORP (eol_type
))
6397 /* Note: composition handling is not yet implemented. */
6398 coding
->common_flags
&= ~CODING_ANNOTATE_COMPOSITION_MASK
;
6400 if (NILP (coding
->src_object
))
6401 stop
= stop_composition
= stop_charset
= end_pos
;
6404 if (coding
->common_flags
& CODING_ANNOTATE_COMPOSITION_MASK
)
6405 stop
= stop_composition
= pos
;
6407 stop
= stop_composition
= end_pos
;
6408 if (coding
->common_flags
& CODING_ANNOTATE_CHARSET_MASK
)
6409 stop
= stop_charset
= pos
;
6411 stop_charset
= end_pos
;
6414 /* Compensate for CRLF and conversion. */
6415 buf_end
-= 1 + MAX_ANNOTATION_LENGTH
;
6416 while (buf
< buf_end
)
6424 if (pos
== stop_composition
)
6425 buf
= handle_composition_annotation (pos
, end_pos
, coding
,
6426 buf
, &stop_composition
);
6427 if (pos
== stop_charset
)
6428 buf
= handle_charset_annotation (pos
, end_pos
, coding
,
6429 buf
, &stop_charset
);
6430 stop
= (stop_composition
< stop_charset
6431 ? stop_composition
: stop_charset
);
6438 if (coding
->encoder
== encode_coding_raw_text
)
6440 else if ((bytes
= MULTIBYTE_LENGTH (src
, src_end
)) > 0)
6441 c
= STRING_CHAR_ADVANCE (src
), pos
+= bytes
;
6443 c
= BYTE8_TO_CHAR (*src
), src
++, pos
++;
6446 c
= STRING_CHAR_ADVANCE (src
), pos
++;
6447 if ((c
== '\r') && (coding
->mode
& CODING_MODE_SELECTIVE_DISPLAY
))
6449 if (! EQ (eol_type
, Qunix
))
6453 if (EQ (eol_type
, Qdos
))
6461 LOOKUP_TRANSLATION_TABLE (translation_table
, c
, trans
);
6466 int from_nchars
= 1, to_nchars
= 1;
6467 int *lookup_buf_end
;
6468 const unsigned char *p
= src
;
6472 for (i
= 1; i
< max_lookup
&& p
< src_end
; i
++)
6473 lookup_buf
[i
] = STRING_CHAR_ADVANCE (p
);
6474 lookup_buf_end
= lookup_buf
+ i
;
6475 trans
= get_translation (trans
, lookup_buf
, lookup_buf_end
, 1,
6476 &from_nchars
, &to_nchars
);
6478 || buf
+ to_nchars
> buf_end
)
6480 *buf
++ = *lookup_buf
;
6481 for (i
= 1; i
< to_nchars
; i
++)
6482 *buf
++ = XINT (AREF (trans
, i
));
6483 for (i
= 1; i
< from_nchars
; i
++, pos
++)
6484 src
+= MULTIBYTE_LENGTH_NO_CHECK (src
);
6488 coding
->consumed
= src
- coding
->source
;
6489 coding
->consumed_char
= pos
- coding
->src_pos
;
6490 coding
->charbuf_used
= buf
- coding
->charbuf
;
6491 coding
->chars_at_source
= 0;
6495 /* Encode the text at CODING->src_object into CODING->dst_object.
6496 CODING->src_object is a buffer or a string.
6497 CODING->dst_object is a buffer or nil.
6499 If CODING->src_object is a buffer, it must be the current buffer.
6500 In this case, if CODING->src_pos is positive, it is a position of
6501 the source text in the buffer, otherwise. the source text is in the
6502 gap area of the buffer, and coding->src_pos specifies the offset of
6503 the text from GPT (which must be the same as PT). If this is the
6504 same buffer as CODING->dst_object, CODING->src_pos must be
6505 negative and CODING should not have `pre-write-conversion'.
6507 If CODING->src_object is a string, CODING should not have
6508 `pre-write-conversion'.
6510 If CODING->dst_object is a buffer, the encoded data is inserted at
6511 the current point of that buffer.
6513 If CODING->dst_object is nil, the encoded data is placed at the
6514 memory area specified by CODING->destination. */
6517 encode_coding (coding
)
6518 struct coding_system
*coding
;
6521 Lisp_Object translation_table
;
6524 attrs
= CODING_ID_ATTRS (coding
->id
);
6525 if (coding
->encoder
== encode_coding_raw_text
)
6526 translation_table
= Qnil
, max_lookup
= 0;
6528 translation_table
= get_translation_table (attrs
, 1, &max_lookup
);
6530 if (BUFFERP (coding
->dst_object
))
6532 set_buffer_internal (XBUFFER (coding
->dst_object
));
6533 coding
->dst_multibyte
6534 = ! NILP (current_buffer
->enable_multibyte_characters
);
6537 coding
->consumed
= coding
->consumed_char
= 0;
6538 coding
->produced
= coding
->produced_char
= 0;
6539 record_conversion_result (coding
, CODING_RESULT_SUCCESS
);
6542 ALLOC_CONVERSION_WORK_AREA (coding
);
6545 coding_set_source (coding
);
6546 consume_chars (coding
, translation_table
, max_lookup
);
6547 coding_set_destination (coding
);
6548 (*(coding
->encoder
)) (coding
);
6549 } while (coding
->consumed_char
< coding
->src_chars
);
6551 if (BUFFERP (coding
->dst_object
))
6552 insert_from_gap (coding
->produced_char
, coding
->produced
);
6554 return (coding
->result
);
6558 /* Name (or base name) of work buffer for code conversion. */
6559 static Lisp_Object Vcode_conversion_workbuf_name
;
6561 /* A working buffer used by the top level conversion. Once it is
6562 created, it is never destroyed. It has the name
6563 Vcode_conversion_workbuf_name. The other working buffers are
6564 destroyed after the use is finished, and their names are modified
6565 versions of Vcode_conversion_workbuf_name. */
6566 static Lisp_Object Vcode_conversion_reused_workbuf
;
6568 /* 1 iff Vcode_conversion_reused_workbuf is already in use. */
6569 static int reused_workbuf_in_use
;
6572 /* Return a working buffer of code convesion. MULTIBYTE specifies the
6573 multibyteness of returning buffer. */
6576 make_conversion_work_buffer (multibyte
)
6579 Lisp_Object name
, workbuf
;
6580 struct buffer
*current
;
6582 if (reused_workbuf_in_use
++)
6584 name
= Fgenerate_new_buffer_name (Vcode_conversion_workbuf_name
, Qnil
);
6585 workbuf
= Fget_buffer_create (name
);
6589 name
= Vcode_conversion_workbuf_name
;
6590 workbuf
= Fget_buffer_create (name
);
6591 if (NILP (Vcode_conversion_reused_workbuf
))
6592 Vcode_conversion_reused_workbuf
= workbuf
;
6594 current
= current_buffer
;
6595 set_buffer_internal (XBUFFER (workbuf
));
6597 current_buffer
->undo_list
= Qt
;
6598 current_buffer
->enable_multibyte_characters
= multibyte
? Qt
: Qnil
;
6599 set_buffer_internal (current
);
6605 code_conversion_restore (arg
)
6608 Lisp_Object current
, workbuf
;
6609 struct gcpro gcpro1
;
6612 current
= XCAR (arg
);
6613 workbuf
= XCDR (arg
);
6614 if (! NILP (workbuf
))
6616 if (EQ (workbuf
, Vcode_conversion_reused_workbuf
))
6617 reused_workbuf_in_use
= 0;
6618 else if (! NILP (Fbuffer_live_p (workbuf
)))
6619 Fkill_buffer (workbuf
);
6621 set_buffer_internal (XBUFFER (current
));
6627 code_conversion_save (with_work_buf
, multibyte
)
6628 int with_work_buf
, multibyte
;
6630 Lisp_Object workbuf
= Qnil
;
6633 workbuf
= make_conversion_work_buffer (multibyte
);
6634 record_unwind_protect (code_conversion_restore
,
6635 Fcons (Fcurrent_buffer (), workbuf
));
6640 decode_coding_gap (coding
, chars
, bytes
)
6641 struct coding_system
*coding
;
6642 EMACS_INT chars
, bytes
;
6644 int count
= specpdl_ptr
- specpdl
;
6647 code_conversion_save (0, 0);
6649 coding
->src_object
= Fcurrent_buffer ();
6650 coding
->src_chars
= chars
;
6651 coding
->src_bytes
= bytes
;
6652 coding
->src_pos
= -chars
;
6653 coding
->src_pos_byte
= -bytes
;
6654 coding
->src_multibyte
= chars
< bytes
;
6655 coding
->dst_object
= coding
->src_object
;
6656 coding
->dst_pos
= PT
;
6657 coding
->dst_pos_byte
= PT_BYTE
;
6658 coding
->dst_multibyte
= ! NILP (current_buffer
->enable_multibyte_characters
);
6660 if (CODING_REQUIRE_DETECTION (coding
))
6661 detect_coding (coding
);
6663 coding
->mode
|= CODING_MODE_LAST_BLOCK
;
6664 decode_coding (coding
);
6666 attrs
= CODING_ID_ATTRS (coding
->id
);
6667 if (! NILP (CODING_ATTR_POST_READ (attrs
)))
6669 EMACS_INT prev_Z
= Z
, prev_Z_BYTE
= Z_BYTE
;
6672 TEMP_SET_PT_BOTH (coding
->dst_pos
, coding
->dst_pos_byte
);
6673 val
= call1 (CODING_ATTR_POST_READ (attrs
),
6674 make_number (coding
->produced_char
));
6676 coding
->produced_char
+= Z
- prev_Z
;
6677 coding
->produced
+= Z_BYTE
- prev_Z_BYTE
;
6680 unbind_to (count
, Qnil
);
6681 return coding
->result
;
6685 encode_coding_gap (coding
, chars
, bytes
)
6686 struct coding_system
*coding
;
6687 EMACS_INT chars
, bytes
;
6689 int count
= specpdl_ptr
- specpdl
;
6691 code_conversion_save (0, 0);
6693 coding
->src_object
= Fcurrent_buffer ();
6694 coding
->src_chars
= chars
;
6695 coding
->src_bytes
= bytes
;
6696 coding
->src_pos
= -chars
;
6697 coding
->src_pos_byte
= -bytes
;
6698 coding
->src_multibyte
= chars
< bytes
;
6699 coding
->dst_object
= coding
->src_object
;
6700 coding
->dst_pos
= PT
;
6701 coding
->dst_pos_byte
= PT_BYTE
;
6703 encode_coding (coding
);
6705 unbind_to (count
, Qnil
);
6706 return coding
->result
;
6710 /* Decode the text in the range FROM/FROM_BYTE and TO/TO_BYTE in
6711 SRC_OBJECT into DST_OBJECT by coding context CODING.
6713 SRC_OBJECT is a buffer, a string, or Qnil.
6715 If it is a buffer, the text is at point of the buffer. FROM and TO
6716 are positions in the buffer.
6718 If it is a string, the text is at the beginning of the string.
6719 FROM and TO are indices to the string.
6721 If it is nil, the text is at coding->source. FROM and TO are
6722 indices to coding->source.
6724 DST_OBJECT is a buffer, Qt, or Qnil.
6726 If it is a buffer, the decoded text is inserted at point of the
6727 buffer. If the buffer is the same as SRC_OBJECT, the source text
6730 If it is Qt, a string is made from the decoded text, and
6731 set in CODING->dst_object.
6733 If it is Qnil, the decoded text is stored at CODING->destination.
6734 The caller must allocate CODING->dst_bytes bytes at
6735 CODING->destination by xmalloc. If the decoded text is longer than
6736 CODING->dst_bytes, CODING->destination is relocated by xrealloc.
6740 decode_coding_object (coding
, src_object
, from
, from_byte
, to
, to_byte
,
6742 struct coding_system
*coding
;
6743 Lisp_Object src_object
;
6744 EMACS_INT from
, from_byte
, to
, to_byte
;
6745 Lisp_Object dst_object
;
6747 int count
= specpdl_ptr
- specpdl
;
6748 unsigned char *destination
;
6749 EMACS_INT dst_bytes
;
6750 EMACS_INT chars
= to
- from
;
6751 EMACS_INT bytes
= to_byte
- from_byte
;
6754 int saved_pt
= -1, saved_pt_byte
;
6756 buffer
= Fcurrent_buffer ();
6758 if (NILP (dst_object
))
6760 destination
= coding
->destination
;
6761 dst_bytes
= coding
->dst_bytes
;
6764 coding
->src_object
= src_object
;
6765 coding
->src_chars
= chars
;
6766 coding
->src_bytes
= bytes
;
6767 coding
->src_multibyte
= chars
< bytes
;
6769 if (STRINGP (src_object
))
6771 coding
->src_pos
= from
;
6772 coding
->src_pos_byte
= from_byte
;
6774 else if (BUFFERP (src_object
))
6776 set_buffer_internal (XBUFFER (src_object
));
6778 move_gap_both (from
, from_byte
);
6779 if (EQ (src_object
, dst_object
))
6781 saved_pt
= PT
, saved_pt_byte
= PT_BYTE
;
6782 TEMP_SET_PT_BOTH (from
, from_byte
);
6783 del_range_both (from
, from_byte
, to
, to_byte
, 1);
6784 coding
->src_pos
= -chars
;
6785 coding
->src_pos_byte
= -bytes
;
6789 coding
->src_pos
= from
;
6790 coding
->src_pos_byte
= from_byte
;
6794 if (CODING_REQUIRE_DETECTION (coding
))
6795 detect_coding (coding
);
6796 attrs
= CODING_ID_ATTRS (coding
->id
);
6798 if (EQ (dst_object
, Qt
)
6799 || (! NILP (CODING_ATTR_POST_READ (attrs
))
6800 && NILP (dst_object
)))
6802 coding
->dst_object
= code_conversion_save (1, 1);
6803 coding
->dst_pos
= BEG
;
6804 coding
->dst_pos_byte
= BEG_BYTE
;
6805 coding
->dst_multibyte
= 1;
6807 else if (BUFFERP (dst_object
))
6809 code_conversion_save (0, 0);
6810 coding
->dst_object
= dst_object
;
6811 coding
->dst_pos
= BUF_PT (XBUFFER (dst_object
));
6812 coding
->dst_pos_byte
= BUF_PT_BYTE (XBUFFER (dst_object
));
6813 coding
->dst_multibyte
6814 = ! NILP (XBUFFER (dst_object
)->enable_multibyte_characters
);
6818 code_conversion_save (0, 0);
6819 coding
->dst_object
= Qnil
;
6820 coding
->dst_multibyte
= 1;
6823 decode_coding (coding
);
6825 if (BUFFERP (coding
->dst_object
))
6826 set_buffer_internal (XBUFFER (coding
->dst_object
));
6828 if (! NILP (CODING_ATTR_POST_READ (attrs
)))
6830 struct gcpro gcpro1
, gcpro2
;
6831 EMACS_INT prev_Z
= Z
, prev_Z_BYTE
= Z_BYTE
;
6834 TEMP_SET_PT_BOTH (coding
->dst_pos
, coding
->dst_pos_byte
);
6835 GCPRO2 (coding
->src_object
, coding
->dst_object
);
6836 val
= safe_call1 (CODING_ATTR_POST_READ (attrs
),
6837 make_number (coding
->produced_char
));
6840 coding
->produced_char
+= Z
- prev_Z
;
6841 coding
->produced
+= Z_BYTE
- prev_Z_BYTE
;
6844 if (EQ (dst_object
, Qt
))
6846 coding
->dst_object
= Fbuffer_string ();
6848 else if (NILP (dst_object
) && BUFFERP (coding
->dst_object
))
6850 set_buffer_internal (XBUFFER (coding
->dst_object
));
6851 if (dst_bytes
< coding
->produced
)
6854 = (unsigned char *) xrealloc (destination
, coding
->produced
);
6857 record_conversion_result (coding
,
6858 CODING_RESULT_INSUFFICIENT_DST
);
6859 unbind_to (count
, Qnil
);
6862 if (BEGV
< GPT
&& GPT
< BEGV
+ coding
->produced_char
)
6863 move_gap_both (BEGV
, BEGV_BYTE
);
6864 bcopy (BEGV_ADDR
, destination
, coding
->produced
);
6865 coding
->destination
= destination
;
6871 /* This is the case of:
6872 (BUFFERP (src_object) && EQ (src_object, dst_object))
6873 As we have moved PT while replacing the original buffer
6874 contents, we must recover it now. */
6875 set_buffer_internal (XBUFFER (src_object
));
6876 if (saved_pt
< from
)
6877 TEMP_SET_PT_BOTH (saved_pt
, saved_pt_byte
);
6878 else if (saved_pt
< from
+ chars
)
6879 TEMP_SET_PT_BOTH (from
, from_byte
);
6880 else if (! NILP (current_buffer
->enable_multibyte_characters
))
6881 TEMP_SET_PT_BOTH (saved_pt
+ (coding
->produced_char
- chars
),
6882 saved_pt_byte
+ (coding
->produced
- bytes
));
6884 TEMP_SET_PT_BOTH (saved_pt
+ (coding
->produced
- bytes
),
6885 saved_pt_byte
+ (coding
->produced
- bytes
));
6888 unbind_to (count
, coding
->dst_object
);
6893 encode_coding_object (coding
, src_object
, from
, from_byte
, to
, to_byte
,
6895 struct coding_system
*coding
;
6896 Lisp_Object src_object
;
6897 EMACS_INT from
, from_byte
, to
, to_byte
;
6898 Lisp_Object dst_object
;
6900 int count
= specpdl_ptr
- specpdl
;
6901 EMACS_INT chars
= to
- from
;
6902 EMACS_INT bytes
= to_byte
- from_byte
;
6905 int saved_pt
= -1, saved_pt_byte
;
6906 int kill_src_buffer
= 0;
6908 buffer
= Fcurrent_buffer ();
6910 coding
->src_object
= src_object
;
6911 coding
->src_chars
= chars
;
6912 coding
->src_bytes
= bytes
;
6913 coding
->src_multibyte
= chars
< bytes
;
6915 attrs
= CODING_ID_ATTRS (coding
->id
);
6917 if (! NILP (CODING_ATTR_PRE_WRITE (attrs
)))
6919 coding
->src_object
= code_conversion_save (1, coding
->src_multibyte
);
6920 set_buffer_internal (XBUFFER (coding
->src_object
));
6921 if (STRINGP (src_object
))
6922 insert_from_string (src_object
, from
, from_byte
, chars
, bytes
, 0);
6923 else if (BUFFERP (src_object
))
6924 insert_from_buffer (XBUFFER (src_object
), from
, chars
, 0);
6926 insert_1_both (coding
->source
+ from
, chars
, bytes
, 0, 0, 0);
6928 if (EQ (src_object
, dst_object
))
6930 set_buffer_internal (XBUFFER (src_object
));
6931 saved_pt
= PT
, saved_pt_byte
= PT_BYTE
;
6932 del_range_both (from
, from_byte
, to
, to_byte
, 1);
6933 set_buffer_internal (XBUFFER (coding
->src_object
));
6937 Lisp_Object args
[3];
6939 args
[0] = CODING_ATTR_PRE_WRITE (attrs
);
6940 args
[1] = make_number (BEG
);
6941 args
[2] = make_number (Z
);
6942 safe_call (3, args
);
6944 if (XBUFFER (coding
->src_object
) != current_buffer
)
6945 kill_src_buffer
= 1;
6946 coding
->src_object
= Fcurrent_buffer ();
6948 move_gap_both (BEG
, BEG_BYTE
);
6949 coding
->src_chars
= Z
- BEG
;
6950 coding
->src_bytes
= Z_BYTE
- BEG_BYTE
;
6951 coding
->src_pos
= BEG
;
6952 coding
->src_pos_byte
= BEG_BYTE
;
6953 coding
->src_multibyte
= Z
< Z_BYTE
;
6955 else if (STRINGP (src_object
))
6957 code_conversion_save (0, 0);
6958 coding
->src_pos
= from
;
6959 coding
->src_pos_byte
= from_byte
;
6961 else if (BUFFERP (src_object
))
6963 code_conversion_save (0, 0);
6964 set_buffer_internal (XBUFFER (src_object
));
6965 if (EQ (src_object
, dst_object
))
6967 saved_pt
= PT
, saved_pt_byte
= PT_BYTE
;
6968 coding
->src_object
= del_range_1 (from
, to
, 1, 1);
6969 coding
->src_pos
= 0;
6970 coding
->src_pos_byte
= 0;
6974 if (from
< GPT
&& to
>= GPT
)
6975 move_gap_both (from
, from_byte
);
6976 coding
->src_pos
= from
;
6977 coding
->src_pos_byte
= from_byte
;
6981 code_conversion_save (0, 0);
6983 if (BUFFERP (dst_object
))
6985 coding
->dst_object
= dst_object
;
6986 if (EQ (src_object
, dst_object
))
6988 coding
->dst_pos
= from
;
6989 coding
->dst_pos_byte
= from_byte
;
6993 coding
->dst_pos
= BUF_PT (XBUFFER (dst_object
));
6994 coding
->dst_pos_byte
= BUF_PT_BYTE (XBUFFER (dst_object
));
6996 coding
->dst_multibyte
6997 = ! NILP (XBUFFER (dst_object
)->enable_multibyte_characters
);
6999 else if (EQ (dst_object
, Qt
))
7001 coding
->dst_object
= Qnil
;
7002 coding
->dst_bytes
= coding
->src_chars
;
7003 if (coding
->dst_bytes
== 0)
7004 coding
->dst_bytes
= 1;
7005 coding
->destination
= (unsigned char *) xmalloc (coding
->dst_bytes
);
7006 coding
->dst_multibyte
= 0;
7010 coding
->dst_object
= Qnil
;
7011 coding
->dst_multibyte
= 0;
7014 encode_coding (coding
);
7016 if (EQ (dst_object
, Qt
))
7018 if (BUFFERP (coding
->dst_object
))
7019 coding
->dst_object
= Fbuffer_string ();
7023 = make_unibyte_string ((char *) coding
->destination
,
7025 xfree (coding
->destination
);
7031 /* This is the case of:
7032 (BUFFERP (src_object) && EQ (src_object, dst_object))
7033 As we have moved PT while replacing the original buffer
7034 contents, we must recover it now. */
7035 set_buffer_internal (XBUFFER (src_object
));
7036 if (saved_pt
< from
)
7037 TEMP_SET_PT_BOTH (saved_pt
, saved_pt_byte
);
7038 else if (saved_pt
< from
+ chars
)
7039 TEMP_SET_PT_BOTH (from
, from_byte
);
7040 else if (! NILP (current_buffer
->enable_multibyte_characters
))
7041 TEMP_SET_PT_BOTH (saved_pt
+ (coding
->produced_char
- chars
),
7042 saved_pt_byte
+ (coding
->produced
- bytes
));
7044 TEMP_SET_PT_BOTH (saved_pt
+ (coding
->produced
- bytes
),
7045 saved_pt_byte
+ (coding
->produced
- bytes
));
7048 if (kill_src_buffer
)
7049 Fkill_buffer (coding
->src_object
);
7050 unbind_to (count
, Qnil
);
7055 preferred_coding_system ()
7057 int id
= coding_categories
[coding_priorities
[0]].id
;
7059 return CODING_ID_NAME (id
);
7064 /*** 8. Emacs Lisp library functions ***/
7066 DEFUN ("coding-system-p", Fcoding_system_p
, Scoding_system_p
, 1, 1, 0,
7067 doc
: /* Return t if OBJECT is nil or a coding-system.
7068 See the documentation of `define-coding-system' for information
7069 about coding-system objects. */)
7074 || CODING_SYSTEM_ID (obj
) >= 0)
7077 || NILP (Fget (obj
, Qcoding_system_define_form
)))
7082 DEFUN ("read-non-nil-coding-system", Fread_non_nil_coding_system
,
7083 Sread_non_nil_coding_system
, 1, 1, 0,
7084 doc
: /* Read a coding system from the minibuffer, prompting with string PROMPT. */)
7091 val
= Fcompleting_read (prompt
, Vcoding_system_alist
, Qnil
,
7092 Qt
, Qnil
, Qcoding_system_history
, Qnil
, Qnil
);
7094 while (SCHARS (val
) == 0);
7095 return (Fintern (val
, Qnil
));
7098 DEFUN ("read-coding-system", Fread_coding_system
, Sread_coding_system
, 1, 2, 0,
7099 doc
: /* Read a coding system from the minibuffer, prompting with string PROMPT.
7100 If the user enters null input, return second argument DEFAULT-CODING-SYSTEM. */)
7101 (prompt
, default_coding_system
)
7102 Lisp_Object prompt
, default_coding_system
;
7105 if (SYMBOLP (default_coding_system
))
7106 XSETSTRING (default_coding_system
, XPNTR (SYMBOL_NAME (default_coding_system
)));
7107 val
= Fcompleting_read (prompt
, Vcoding_system_alist
, Qnil
,
7108 Qt
, Qnil
, Qcoding_system_history
,
7109 default_coding_system
, Qnil
);
7110 return (SCHARS (val
) == 0 ? Qnil
: Fintern (val
, Qnil
));
7113 DEFUN ("check-coding-system", Fcheck_coding_system
, Scheck_coding_system
,
7115 doc
: /* Check validity of CODING-SYSTEM.
7116 If valid, return CODING-SYSTEM, else signal a `coding-system-error' error.
7117 It is valid if it is nil or a symbol defined as a coding system by the
7118 function `define-coding-system'. */)
7120 Lisp_Object coding_system
;
7122 Lisp_Object define_form
;
7124 define_form
= Fget (coding_system
, Qcoding_system_define_form
);
7125 if (! NILP (define_form
))
7127 Fput (coding_system
, Qcoding_system_define_form
, Qnil
);
7128 safe_eval (define_form
);
7130 if (!NILP (Fcoding_system_p (coding_system
)))
7131 return coding_system
;
7133 Fsignal (Qcoding_system_error
, Fcons (coding_system
, Qnil
));
7137 /* Detect how the bytes at SRC of length SRC_BYTES are encoded. If
7138 HIGHEST is nonzero, return the coding system of the highest
7139 priority among the detected coding systems. Otherwize return a
7140 list of detected coding systems sorted by their priorities. If
7141 MULTIBYTEP is nonzero, it is assumed that the bytes are in correct
7142 multibyte form but contains only ASCII and eight-bit chars.
7143 Otherwise, the bytes are raw bytes.
7145 CODING-SYSTEM controls the detection as below:
7147 If it is nil, detect both text-format and eol-format. If the
7148 text-format part of CODING-SYSTEM is already specified
7149 (e.g. `iso-latin-1'), detect only eol-format. If the eol-format
7150 part of CODING-SYSTEM is already specified (e.g. `undecided-unix'),
7151 detect only text-format. */
7154 detect_coding_system (src
, src_chars
, src_bytes
, highest
, multibytep
,
7156 const unsigned char *src
;
7157 int src_chars
, src_bytes
, highest
;
7159 Lisp_Object coding_system
;
7161 const unsigned char *src_end
= src
+ src_bytes
;
7162 Lisp_Object attrs
, eol_type
;
7164 struct coding_system coding
;
7166 struct coding_detection_info detect_info
;
7167 enum coding_category base_category
;
7169 if (NILP (coding_system
))
7170 coding_system
= Qundecided
;
7171 setup_coding_system (coding_system
, &coding
);
7172 attrs
= CODING_ID_ATTRS (coding
.id
);
7173 eol_type
= CODING_ID_EOL_TYPE (coding
.id
);
7174 coding_system
= CODING_ATTR_BASE_NAME (attrs
);
7176 coding
.source
= src
;
7177 coding
.src_chars
= src_chars
;
7178 coding
.src_bytes
= src_bytes
;
7179 coding
.src_multibyte
= multibytep
;
7180 coding
.consumed
= 0;
7181 coding
.mode
|= CODING_MODE_LAST_BLOCK
;
7183 detect_info
.checked
= detect_info
.found
= detect_info
.rejected
= 0;
7185 /* At first, detect text-format if necessary. */
7186 base_category
= XINT (CODING_ATTR_CATEGORY (attrs
));
7187 if (base_category
== coding_category_undecided
)
7189 enum coding_category category
;
7190 struct coding_system
*this;
7193 /* Skip all ASCII bytes except for a few ISO2022 controls. */
7194 for (i
= 0; src
< src_end
; i
++, src
++)
7200 && (c
== ISO_CODE_ESC
|| c
== ISO_CODE_SI
|| c
== ISO_CODE_SO
)
7201 && inhibit_iso_escape_detection
)
7203 coding
.head_ascii
= src
- coding
.source
;
7204 if (detect_coding_iso_2022 (&coding
, &detect_info
))
7206 /* We have scanned the whole data. */
7207 if (! (detect_info
.rejected
& CATEGORY_MASK_ISO_7_ELSE
))
7208 /* We didn't find an 8-bit code. */
7214 coding
.head_ascii
= src
- coding
.source
;
7217 || detect_info
.found
)
7220 /* As all bytes are 7-bit, we can ignore non-ISO-2022 codings. */
7221 for (i
= 0; i
< coding_category_raw_text
; i
++)
7223 category
= coding_priorities
[i
];
7224 if (detect_info
.found
& (1 << category
))
7228 for (i
= 0; i
< coding_category_raw_text
; i
++)
7230 category
= coding_priorities
[i
];
7231 this = coding_categories
+ category
;
7235 /* No coding system of this category is defined. */
7236 detect_info
.rejected
|= (1 << category
);
7238 else if (category
>= coding_category_raw_text
)
7240 else if (detect_info
.checked
& (1 << category
))
7243 && (detect_info
.found
& (1 << category
)))
7248 if ((*(this->detector
)) (&coding
, &detect_info
)
7250 && (detect_info
.found
& (1 << category
)))
7252 if (category
== coding_category_utf_16_auto
)
7254 if (detect_info
.found
& CATEGORY_MASK_UTF_16_LE
)
7255 category
= coding_category_utf_16_le
;
7257 category
= coding_category_utf_16_be
;
7265 if (detect_info
.rejected
== CATEGORY_MASK_ANY
)
7267 detect_info
.found
= CATEGORY_MASK_RAW_TEXT
;
7268 id
= coding_categories
[coding_category_raw_text
].id
;
7269 val
= Fcons (make_number (id
), Qnil
);
7271 else if (! detect_info
.rejected
&& ! detect_info
.found
)
7273 detect_info
.found
= CATEGORY_MASK_ANY
;
7274 id
= coding_categories
[coding_category_undecided
].id
;
7275 val
= Fcons (make_number (id
), Qnil
);
7279 if (detect_info
.found
)
7281 detect_info
.found
= 1 << category
;
7282 val
= Fcons (make_number (this->id
), Qnil
);
7285 for (i
= 0; i
< coding_category_raw_text
; i
++)
7286 if (! (detect_info
.rejected
& (1 << coding_priorities
[i
])))
7288 detect_info
.found
= 1 << coding_priorities
[i
];
7289 id
= coding_categories
[coding_priorities
[i
]].id
;
7290 val
= Fcons (make_number (id
), Qnil
);
7296 int mask
= detect_info
.rejected
| detect_info
.found
;
7300 for (i
= coding_category_raw_text
- 1; i
>= 0; i
--)
7302 category
= coding_priorities
[i
];
7303 if (! (mask
& (1 << category
)))
7305 found
|= 1 << category
;
7306 id
= coding_categories
[category
].id
;
7307 val
= Fcons (make_number (id
), val
);
7310 for (i
= coding_category_raw_text
- 1; i
>= 0; i
--)
7312 category
= coding_priorities
[i
];
7313 if (detect_info
.found
& (1 << category
))
7315 id
= coding_categories
[category
].id
;
7316 val
= Fcons (make_number (id
), val
);
7319 detect_info
.found
|= found
;
7322 else if (base_category
== coding_category_utf_16_auto
)
7324 if (detect_coding_utf_16 (&coding
, &detect_info
))
7326 struct coding_system
*this;
7328 if (detect_info
.found
& CATEGORY_MASK_UTF_16_LE
)
7329 this = coding_categories
+ coding_category_utf_16_le
;
7330 else if (detect_info
.found
& CATEGORY_MASK_UTF_16_BE
)
7331 this = coding_categories
+ coding_category_utf_16_be
;
7332 else if (detect_info
.rejected
& CATEGORY_MASK_UTF_16_LE_NOSIG
)
7333 this = coding_categories
+ coding_category_utf_16_be_nosig
;
7335 this = coding_categories
+ coding_category_utf_16_le_nosig
;
7336 val
= Fcons (make_number (this->id
), Qnil
);
7341 detect_info
.found
= 1 << XINT (CODING_ATTR_CATEGORY (attrs
));
7342 val
= Fcons (make_number (coding
.id
), Qnil
);
7345 /* Then, detect eol-format if necessary. */
7347 int normal_eol
= -1, utf_16_be_eol
= -1, utf_16_le_eol
;
7350 if (VECTORP (eol_type
))
7352 if (detect_info
.found
& ~CATEGORY_MASK_UTF_16
)
7353 normal_eol
= detect_eol (coding
.source
, src_bytes
,
7354 coding_category_raw_text
);
7355 if (detect_info
.found
& (CATEGORY_MASK_UTF_16_BE
7356 | CATEGORY_MASK_UTF_16_BE_NOSIG
))
7357 utf_16_be_eol
= detect_eol (coding
.source
, src_bytes
,
7358 coding_category_utf_16_be
);
7359 if (detect_info
.found
& (CATEGORY_MASK_UTF_16_LE
7360 | CATEGORY_MASK_UTF_16_LE_NOSIG
))
7361 utf_16_le_eol
= detect_eol (coding
.source
, src_bytes
,
7362 coding_category_utf_16_le
);
7366 if (EQ (eol_type
, Qunix
))
7367 normal_eol
= utf_16_be_eol
= utf_16_le_eol
= EOL_SEEN_LF
;
7368 else if (EQ (eol_type
, Qdos
))
7369 normal_eol
= utf_16_be_eol
= utf_16_le_eol
= EOL_SEEN_CRLF
;
7371 normal_eol
= utf_16_be_eol
= utf_16_le_eol
= EOL_SEEN_CR
;
7374 for (tail
= val
; CONSP (tail
); tail
= XCDR (tail
))
7376 enum coding_category category
;
7379 id
= XINT (XCAR (tail
));
7380 attrs
= CODING_ID_ATTRS (id
);
7381 category
= XINT (CODING_ATTR_CATEGORY (attrs
));
7382 eol_type
= CODING_ID_EOL_TYPE (id
);
7383 if (VECTORP (eol_type
))
7385 if (category
== coding_category_utf_16_be
7386 || category
== coding_category_utf_16_be_nosig
)
7387 this_eol
= utf_16_be_eol
;
7388 else if (category
== coding_category_utf_16_le
7389 || category
== coding_category_utf_16_le_nosig
)
7390 this_eol
= utf_16_le_eol
;
7392 this_eol
= normal_eol
;
7394 if (this_eol
== EOL_SEEN_LF
)
7395 XSETCAR (tail
, AREF (eol_type
, 0));
7396 else if (this_eol
== EOL_SEEN_CRLF
)
7397 XSETCAR (tail
, AREF (eol_type
, 1));
7398 else if (this_eol
== EOL_SEEN_CR
)
7399 XSETCAR (tail
, AREF (eol_type
, 2));
7401 XSETCAR (tail
, CODING_ID_NAME (id
));
7404 XSETCAR (tail
, CODING_ID_NAME (id
));
7408 return (highest
? XCAR (val
) : val
);
7412 DEFUN ("detect-coding-region", Fdetect_coding_region
, Sdetect_coding_region
,
7414 doc
: /* Detect coding system of the text in the region between START and END.
7415 Return a list of possible coding systems ordered by priority.
7417 If only ASCII characters are found, it returns a list of single element
7418 `undecided' or its subsidiary coding system according to a detected
7421 If optional argument HIGHEST is non-nil, return the coding system of
7422 highest priority. */)
7423 (start
, end
, highest
)
7424 Lisp_Object start
, end
, highest
;
7427 int from_byte
, to_byte
;
7429 CHECK_NUMBER_COERCE_MARKER (start
);
7430 CHECK_NUMBER_COERCE_MARKER (end
);
7432 validate_region (&start
, &end
);
7433 from
= XINT (start
), to
= XINT (end
);
7434 from_byte
= CHAR_TO_BYTE (from
);
7435 to_byte
= CHAR_TO_BYTE (to
);
7437 if (from
< GPT
&& to
>= GPT
)
7438 move_gap_both (to
, to_byte
);
7440 return detect_coding_system (BYTE_POS_ADDR (from_byte
),
7441 to
- from
, to_byte
- from_byte
,
7443 !NILP (current_buffer
7444 ->enable_multibyte_characters
),
7448 DEFUN ("detect-coding-string", Fdetect_coding_string
, Sdetect_coding_string
,
7450 doc
: /* Detect coding system of the text in STRING.
7451 Return a list of possible coding systems ordered by priority.
7453 If only ASCII characters are found, it returns a list of single element
7454 `undecided' or its subsidiary coding system according to a detected
7457 If optional argument HIGHEST is non-nil, return the coding system of
7458 highest priority. */)
7460 Lisp_Object string
, highest
;
7462 CHECK_STRING (string
);
7464 return detect_coding_system (SDATA (string
),
7465 SCHARS (string
), SBYTES (string
),
7466 !NILP (highest
), STRING_MULTIBYTE (string
),
7472 char_encodable_p (c
, attrs
)
7477 struct charset
*charset
;
7478 Lisp_Object translation_table
;
7480 translation_table
= CODING_ATTR_TRANS_TBL (attrs
);
7481 if (! NILP (translation_table
))
7482 c
= translate_char (translation_table
, c
);
7483 for (tail
= CODING_ATTR_CHARSET_LIST (attrs
);
7484 CONSP (tail
); tail
= XCDR (tail
))
7486 charset
= CHARSET_FROM_ID (XINT (XCAR (tail
)));
7487 if (CHAR_CHARSET_P (c
, charset
))
7490 return (! NILP (tail
));
7494 /* Return a list of coding systems that safely encode the text between
7495 START and END. If EXCLUDE is non-nil, it is a list of coding
7496 systems not to check. The returned list doesn't contain any such
7497 coding systems. In any case, if the text contains only ASCII or is
7498 unibyte, return t. */
7500 DEFUN ("find-coding-systems-region-internal",
7501 Ffind_coding_systems_region_internal
,
7502 Sfind_coding_systems_region_internal
, 2, 3, 0,
7503 doc
: /* Internal use only. */)
7504 (start
, end
, exclude
)
7505 Lisp_Object start
, end
, exclude
;
7507 Lisp_Object coding_attrs_list
, safe_codings
;
7508 EMACS_INT start_byte
, end_byte
;
7509 const unsigned char *p
, *pbeg
, *pend
;
7511 Lisp_Object tail
, elt
;
7513 if (STRINGP (start
))
7515 if (!STRING_MULTIBYTE (start
)
7516 || SCHARS (start
) == SBYTES (start
))
7519 end_byte
= SBYTES (start
);
7523 CHECK_NUMBER_COERCE_MARKER (start
);
7524 CHECK_NUMBER_COERCE_MARKER (end
);
7525 if (XINT (start
) < BEG
|| XINT (end
) > Z
|| XINT (start
) > XINT (end
))
7526 args_out_of_range (start
, end
);
7527 if (NILP (current_buffer
->enable_multibyte_characters
))
7529 start_byte
= CHAR_TO_BYTE (XINT (start
));
7530 end_byte
= CHAR_TO_BYTE (XINT (end
));
7531 if (XINT (end
) - XINT (start
) == end_byte
- start_byte
)
7534 if (XINT (start
) < GPT
&& XINT (end
) > GPT
)
7536 if ((GPT
- XINT (start
)) < (XINT (end
) - GPT
))
7537 move_gap_both (XINT (start
), start_byte
);
7539 move_gap_both (XINT (end
), end_byte
);
7543 coding_attrs_list
= Qnil
;
7544 for (tail
= Vcoding_system_list
; CONSP (tail
); tail
= XCDR (tail
))
7546 || NILP (Fmemq (XCAR (tail
), exclude
)))
7550 attrs
= AREF (CODING_SYSTEM_SPEC (XCAR (tail
)), 0);
7551 if (EQ (XCAR (tail
), CODING_ATTR_BASE_NAME (attrs
))
7552 && ! EQ (CODING_ATTR_TYPE (attrs
), Qundecided
))
7554 ASET (attrs
, coding_attr_trans_tbl
,
7555 get_translation_table (attrs
, 1, NULL
));
7556 coding_attrs_list
= Fcons (attrs
, coding_attrs_list
);
7560 if (STRINGP (start
))
7561 p
= pbeg
= SDATA (start
);
7563 p
= pbeg
= BYTE_POS_ADDR (start_byte
);
7564 pend
= p
+ (end_byte
- start_byte
);
7566 while (p
< pend
&& ASCII_BYTE_P (*p
)) p
++;
7567 while (p
< pend
&& ASCII_BYTE_P (*(pend
- 1))) pend
--;
7571 if (ASCII_BYTE_P (*p
))
7575 c
= STRING_CHAR_ADVANCE (p
);
7577 charset_map_loaded
= 0;
7578 for (tail
= coding_attrs_list
; CONSP (tail
);)
7583 else if (char_encodable_p (c
, elt
))
7585 else if (CONSP (XCDR (tail
)))
7587 XSETCAR (tail
, XCAR (XCDR (tail
)));
7588 XSETCDR (tail
, XCDR (XCDR (tail
)));
7592 XSETCAR (tail
, Qnil
);
7596 if (charset_map_loaded
)
7598 EMACS_INT p_offset
= p
- pbeg
, pend_offset
= pend
- pbeg
;
7600 if (STRINGP (start
))
7601 pbeg
= SDATA (start
);
7603 pbeg
= BYTE_POS_ADDR (start_byte
);
7604 p
= pbeg
+ p_offset
;
7605 pend
= pbeg
+ pend_offset
;
7610 safe_codings
= list2 (Qraw_text
, Qno_conversion
);
7611 for (tail
= coding_attrs_list
; CONSP (tail
); tail
= XCDR (tail
))
7612 if (! NILP (XCAR (tail
)))
7613 safe_codings
= Fcons (CODING_ATTR_BASE_NAME (XCAR (tail
)), safe_codings
);
7615 return safe_codings
;
7619 DEFUN ("unencodable-char-position", Funencodable_char_position
,
7620 Sunencodable_char_position
, 3, 5, 0,
7622 Return position of first un-encodable character in a region.
7623 START and END specfiy the region and CODING-SYSTEM specifies the
7624 encoding to check. Return nil if CODING-SYSTEM does encode the region.
7626 If optional 4th argument COUNT is non-nil, it specifies at most how
7627 many un-encodable characters to search. In this case, the value is a
7630 If optional 5th argument STRING is non-nil, it is a string to search
7631 for un-encodable characters. In that case, START and END are indexes
7633 (start
, end
, coding_system
, count
, string
)
7634 Lisp_Object start
, end
, coding_system
, count
, string
;
7637 struct coding_system coding
;
7638 Lisp_Object attrs
, charset_list
, translation_table
;
7639 Lisp_Object positions
;
7641 const unsigned char *p
, *stop
, *pend
;
7642 int ascii_compatible
;
7644 setup_coding_system (Fcheck_coding_system (coding_system
), &coding
);
7645 attrs
= CODING_ID_ATTRS (coding
.id
);
7646 if (EQ (CODING_ATTR_TYPE (attrs
), Qraw_text
))
7648 ascii_compatible
= ! NILP (CODING_ATTR_ASCII_COMPAT (attrs
));
7649 charset_list
= CODING_ATTR_CHARSET_LIST (attrs
);
7650 translation_table
= get_translation_table (attrs
, 1, NULL
);
7654 validate_region (&start
, &end
);
7655 from
= XINT (start
);
7657 if (NILP (current_buffer
->enable_multibyte_characters
)
7658 || (ascii_compatible
7659 && (to
- from
) == (CHAR_TO_BYTE (to
) - (CHAR_TO_BYTE (from
)))))
7661 p
= CHAR_POS_ADDR (from
);
7662 pend
= CHAR_POS_ADDR (to
);
7663 if (from
< GPT
&& to
>= GPT
)
7670 CHECK_STRING (string
);
7671 CHECK_NATNUM (start
);
7673 from
= XINT (start
);
7676 || to
> SCHARS (string
))
7677 args_out_of_range_3 (string
, start
, end
);
7678 if (! STRING_MULTIBYTE (string
))
7680 p
= SDATA (string
) + string_char_to_byte (string
, from
);
7681 stop
= pend
= SDATA (string
) + string_char_to_byte (string
, to
);
7682 if (ascii_compatible
&& (to
- from
) == (pend
- p
))
7690 CHECK_NATNUM (count
);
7699 if (ascii_compatible
)
7700 while (p
< stop
&& ASCII_BYTE_P (*p
))
7710 c
= STRING_CHAR_ADVANCE (p
);
7711 if (! (ASCII_CHAR_P (c
) && ascii_compatible
)
7712 && ! char_charset (translate_char (translation_table
, c
),
7713 charset_list
, NULL
))
7715 positions
= Fcons (make_number (from
), positions
);
7724 return (NILP (count
) ? Fcar (positions
) : Fnreverse (positions
));
7728 DEFUN ("check-coding-systems-region", Fcheck_coding_systems_region
,
7729 Scheck_coding_systems_region
, 3, 3, 0,
7730 doc
: /* Check if the region is encodable by coding systems.
7732 START and END are buffer positions specifying the region.
7733 CODING-SYSTEM-LIST is a list of coding systems to check.
7735 The value is an alist ((CODING-SYSTEM POS0 POS1 ...) ...), where
7736 CODING-SYSTEM is a member of CODING-SYSTEM-LIst and can't encode the
7737 whole region, POS0, POS1, ... are buffer positions where non-encodable
7738 characters are found.
7740 If all coding systems in CODING-SYSTEM-LIST can encode the region, the
7743 START may be a string. In that case, check if the string is
7744 encodable, and the value contains indices to the string instead of
7745 buffer positions. END is ignored. */)
7746 (start
, end
, coding_system_list
)
7747 Lisp_Object start
, end
, coding_system_list
;
7750 EMACS_INT start_byte
, end_byte
;
7752 const unsigned char *p
, *pbeg
, *pend
;
7754 Lisp_Object tail
, elt
, attrs
;
7756 if (STRINGP (start
))
7758 if (!STRING_MULTIBYTE (start
)
7759 && SCHARS (start
) != SBYTES (start
))
7762 end_byte
= SBYTES (start
);
7767 CHECK_NUMBER_COERCE_MARKER (start
);
7768 CHECK_NUMBER_COERCE_MARKER (end
);
7769 if (XINT (start
) < BEG
|| XINT (end
) > Z
|| XINT (start
) > XINT (end
))
7770 args_out_of_range (start
, end
);
7771 if (NILP (current_buffer
->enable_multibyte_characters
))
7773 start_byte
= CHAR_TO_BYTE (XINT (start
));
7774 end_byte
= CHAR_TO_BYTE (XINT (end
));
7775 if (XINT (end
) - XINT (start
) == end_byte
- start_byte
)
7778 if (XINT (start
) < GPT
&& XINT (end
) > GPT
)
7780 if ((GPT
- XINT (start
)) < (XINT (end
) - GPT
))
7781 move_gap_both (XINT (start
), start_byte
);
7783 move_gap_both (XINT (end
), end_byte
);
7789 for (tail
= coding_system_list
; CONSP (tail
); tail
= XCDR (tail
))
7792 attrs
= AREF (CODING_SYSTEM_SPEC (elt
), 0);
7793 ASET (attrs
, coding_attr_trans_tbl
,
7794 get_translation_table (attrs
, 1, NULL
));
7795 list
= Fcons (Fcons (elt
, Fcons (attrs
, Qnil
)), list
);
7798 if (STRINGP (start
))
7799 p
= pbeg
= SDATA (start
);
7801 p
= pbeg
= BYTE_POS_ADDR (start_byte
);
7802 pend
= p
+ (end_byte
- start_byte
);
7804 while (p
< pend
&& ASCII_BYTE_P (*p
)) p
++, pos
++;
7805 while (p
< pend
&& ASCII_BYTE_P (*(pend
- 1))) pend
--;
7809 if (ASCII_BYTE_P (*p
))
7813 c
= STRING_CHAR_ADVANCE (p
);
7815 charset_map_loaded
= 0;
7816 for (tail
= list
; CONSP (tail
); tail
= XCDR (tail
))
7818 elt
= XCDR (XCAR (tail
));
7819 if (! char_encodable_p (c
, XCAR (elt
)))
7820 XSETCDR (elt
, Fcons (make_number (pos
), XCDR (elt
)));
7822 if (charset_map_loaded
)
7824 EMACS_INT p_offset
= p
- pbeg
, pend_offset
= pend
- pbeg
;
7826 if (STRINGP (start
))
7827 pbeg
= SDATA (start
);
7829 pbeg
= BYTE_POS_ADDR (start_byte
);
7830 p
= pbeg
+ p_offset
;
7831 pend
= pbeg
+ pend_offset
;
7839 for (; CONSP (tail
); tail
= XCDR (tail
))
7842 if (CONSP (XCDR (XCDR (elt
))))
7843 list
= Fcons (Fcons (XCAR (elt
), Fnreverse (XCDR (XCDR (elt
)))),
7852 code_convert_region (start
, end
, coding_system
, dst_object
, encodep
, norecord
)
7853 Lisp_Object start
, end
, coding_system
, dst_object
;
7854 int encodep
, norecord
;
7856 struct coding_system coding
;
7857 EMACS_INT from
, from_byte
, to
, to_byte
;
7858 Lisp_Object src_object
;
7860 CHECK_NUMBER_COERCE_MARKER (start
);
7861 CHECK_NUMBER_COERCE_MARKER (end
);
7862 if (NILP (coding_system
))
7863 coding_system
= Qno_conversion
;
7865 CHECK_CODING_SYSTEM (coding_system
);
7866 src_object
= Fcurrent_buffer ();
7867 if (NILP (dst_object
))
7868 dst_object
= src_object
;
7869 else if (! EQ (dst_object
, Qt
))
7870 CHECK_BUFFER (dst_object
);
7872 validate_region (&start
, &end
);
7873 from
= XFASTINT (start
);
7874 from_byte
= CHAR_TO_BYTE (from
);
7875 to
= XFASTINT (end
);
7876 to_byte
= CHAR_TO_BYTE (to
);
7878 setup_coding_system (coding_system
, &coding
);
7879 coding
.mode
|= CODING_MODE_LAST_BLOCK
;
7882 encode_coding_object (&coding
, src_object
, from
, from_byte
, to
, to_byte
,
7885 decode_coding_object (&coding
, src_object
, from
, from_byte
, to
, to_byte
,
7888 Vlast_coding_system_used
= CODING_ID_NAME (coding
.id
);
7890 return (BUFFERP (dst_object
)
7891 ? make_number (coding
.produced_char
)
7892 : coding
.dst_object
);
7896 DEFUN ("decode-coding-region", Fdecode_coding_region
, Sdecode_coding_region
,
7897 3, 4, "r\nzCoding system: ",
7898 doc
: /* Decode the current region from the specified coding system.
7899 When called from a program, takes four arguments:
7900 START, END, CODING-SYSTEM, and DESTINATION.
7901 START and END are buffer positions.
7903 Optional 4th arguments DESTINATION specifies where the decoded text goes.
7904 If nil, the region between START and END is replace by the decoded text.
7905 If buffer, the decoded text is inserted in the buffer.
7906 If t, the decoded text is returned.
7908 This function sets `last-coding-system-used' to the precise coding system
7909 used (which may be different from CODING-SYSTEM if CODING-SYSTEM is
7910 not fully specified.)
7911 It returns the length of the decoded text. */)
7912 (start
, end
, coding_system
, destination
)
7913 Lisp_Object start
, end
, coding_system
, destination
;
7915 return code_convert_region (start
, end
, coding_system
, destination
, 0, 0);
7918 DEFUN ("encode-coding-region", Fencode_coding_region
, Sencode_coding_region
,
7919 3, 4, "r\nzCoding system: ",
7920 doc
: /* Encode the current region by specified coding system.
7921 When called from a program, takes three arguments:
7922 START, END, and CODING-SYSTEM. START and END are buffer positions.
7924 Optional 4th arguments DESTINATION specifies where the encoded text goes.
7925 If nil, the region between START and END is replace by the encoded text.
7926 If buffer, the encoded text is inserted in the buffer.
7927 If t, the encoded text is returned.
7929 This function sets `last-coding-system-used' to the precise coding system
7930 used (which may be different from CODING-SYSTEM if CODING-SYSTEM is
7931 not fully specified.)
7932 It returns the length of the encoded text. */)
7933 (start
, end
, coding_system
, destination
)
7934 Lisp_Object start
, end
, coding_system
, destination
;
7936 return code_convert_region (start
, end
, coding_system
, destination
, 1, 0);
7940 code_convert_string (string
, coding_system
, dst_object
,
7941 encodep
, nocopy
, norecord
)
7942 Lisp_Object string
, coding_system
, dst_object
;
7943 int encodep
, nocopy
, norecord
;
7945 struct coding_system coding
;
7946 EMACS_INT chars
, bytes
;
7948 CHECK_STRING (string
);
7949 if (NILP (coding_system
))
7952 Vlast_coding_system_used
= Qno_conversion
;
7953 if (NILP (dst_object
))
7954 return (nocopy
? Fcopy_sequence (string
) : string
);
7957 if (NILP (coding_system
))
7958 coding_system
= Qno_conversion
;
7960 CHECK_CODING_SYSTEM (coding_system
);
7961 if (NILP (dst_object
))
7963 else if (! EQ (dst_object
, Qt
))
7964 CHECK_BUFFER (dst_object
);
7966 setup_coding_system (coding_system
, &coding
);
7967 coding
.mode
|= CODING_MODE_LAST_BLOCK
;
7968 chars
= SCHARS (string
);
7969 bytes
= SBYTES (string
);
7971 encode_coding_object (&coding
, string
, 0, 0, chars
, bytes
, dst_object
);
7973 decode_coding_object (&coding
, string
, 0, 0, chars
, bytes
, dst_object
);
7975 Vlast_coding_system_used
= CODING_ID_NAME (coding
.id
);
7977 return (BUFFERP (dst_object
)
7978 ? make_number (coding
.produced_char
)
7979 : coding
.dst_object
);
7983 /* Encode or decode STRING according to CODING_SYSTEM.
7984 Do not set Vlast_coding_system_used.
7986 This function is called only from macros DECODE_FILE and
7987 ENCODE_FILE, thus we ignore character composition. */
7990 code_convert_string_norecord (string
, coding_system
, encodep
)
7991 Lisp_Object string
, coding_system
;
7994 return code_convert_string (string
, coding_system
, Qt
, encodep
, 0, 1);
7998 DEFUN ("decode-coding-string", Fdecode_coding_string
, Sdecode_coding_string
,
8000 doc
: /* Decode STRING which is encoded in CODING-SYSTEM, and return the result.
8002 Optional third arg NOCOPY non-nil means it is OK to return STRING itself
8003 if the decoding operation is trivial.
8005 Optional fourth arg BUFFER non-nil meant that the decoded text is
8006 inserted in BUFFER instead of returned as a string. In this case,
8007 the return value is BUFFER.
8009 This function sets `last-coding-system-used' to the precise coding system
8010 used (which may be different from CODING-SYSTEM if CODING-SYSTEM is
8011 not fully specified. */)
8012 (string
, coding_system
, nocopy
, buffer
)
8013 Lisp_Object string
, coding_system
, nocopy
, buffer
;
8015 return code_convert_string (string
, coding_system
, buffer
,
8016 0, ! NILP (nocopy
), 0);
8019 DEFUN ("encode-coding-string", Fencode_coding_string
, Sencode_coding_string
,
8021 doc
: /* Encode STRING to CODING-SYSTEM, and return the result.
8023 Optional third arg NOCOPY non-nil means it is OK to return STRING
8024 itself if the encoding operation is trivial.
8026 Optional fourth arg BUFFER non-nil meant that the encoded text is
8027 inserted in BUFFER instead of returned as a string. In this case,
8028 the return value is BUFFER.
8030 This function sets `last-coding-system-used' to the precise coding system
8031 used (which may be different from CODING-SYSTEM if CODING-SYSTEM is
8032 not fully specified.) */)
8033 (string
, coding_system
, nocopy
, buffer
)
8034 Lisp_Object string
, coding_system
, nocopy
, buffer
;
8036 return code_convert_string (string
, coding_system
, buffer
,
8037 1, ! NILP (nocopy
), 1);
8041 DEFUN ("decode-sjis-char", Fdecode_sjis_char
, Sdecode_sjis_char
, 1, 1, 0,
8042 doc
: /* Decode a Japanese character which has CODE in shift_jis encoding.
8043 Return the corresponding character. */)
8047 Lisp_Object spec
, attrs
, val
;
8048 struct charset
*charset_roman
, *charset_kanji
, *charset_kana
, *charset
;
8051 CHECK_NATNUM (code
);
8052 c
= XFASTINT (code
);
8053 CHECK_CODING_SYSTEM_GET_SPEC (Vsjis_coding_system
, spec
);
8054 attrs
= AREF (spec
, 0);
8056 if (ASCII_BYTE_P (c
)
8057 && ! NILP (CODING_ATTR_ASCII_COMPAT (attrs
)))
8060 val
= CODING_ATTR_CHARSET_LIST (attrs
);
8061 charset_roman
= CHARSET_FROM_ID (XINT (XCAR (val
))), val
= XCDR (val
);
8062 charset_kana
= CHARSET_FROM_ID (XINT (XCAR (val
))), val
= XCDR (val
);
8063 charset_kanji
= CHARSET_FROM_ID (XINT (XCAR (val
)));
8066 charset
= charset_roman
;
8067 else if (c
>= 0xA0 && c
< 0xDF)
8069 charset
= charset_kana
;
8074 int s1
= c
>> 8, s2
= c
& 0xFF;
8076 if (s1
< 0x81 || (s1
> 0x9F && s1
< 0xE0) || s1
> 0xEF
8077 || s2
< 0x40 || s2
== 0x7F || s2
> 0xFC)
8078 error ("Invalid code: %d", code
);
8080 charset
= charset_kanji
;
8082 c
= DECODE_CHAR (charset
, c
);
8084 error ("Invalid code: %d", code
);
8085 return make_number (c
);
8089 DEFUN ("encode-sjis-char", Fencode_sjis_char
, Sencode_sjis_char
, 1, 1, 0,
8090 doc
: /* Encode a Japanese character CHAR to shift_jis encoding.
8091 Return the corresponding code in SJIS. */)
8095 Lisp_Object spec
, attrs
, charset_list
;
8097 struct charset
*charset
;
8100 CHECK_CHARACTER (ch
);
8102 CHECK_CODING_SYSTEM_GET_SPEC (Vsjis_coding_system
, spec
);
8103 attrs
= AREF (spec
, 0);
8105 if (ASCII_CHAR_P (c
)
8106 && ! NILP (CODING_ATTR_ASCII_COMPAT (attrs
)))
8109 charset_list
= CODING_ATTR_CHARSET_LIST (attrs
);
8110 charset
= char_charset (c
, charset_list
, &code
);
8111 if (code
== CHARSET_INVALID_CODE (charset
))
8112 error ("Can't encode by shift_jis encoding: %d", c
);
8115 return make_number (code
);
8118 DEFUN ("decode-big5-char", Fdecode_big5_char
, Sdecode_big5_char
, 1, 1, 0,
8119 doc
: /* Decode a Big5 character which has CODE in BIG5 coding system.
8120 Return the corresponding character. */)
8124 Lisp_Object spec
, attrs
, val
;
8125 struct charset
*charset_roman
, *charset_big5
, *charset
;
8128 CHECK_NATNUM (code
);
8129 c
= XFASTINT (code
);
8130 CHECK_CODING_SYSTEM_GET_SPEC (Vbig5_coding_system
, spec
);
8131 attrs
= AREF (spec
, 0);
8133 if (ASCII_BYTE_P (c
)
8134 && ! NILP (CODING_ATTR_ASCII_COMPAT (attrs
)))
8137 val
= CODING_ATTR_CHARSET_LIST (attrs
);
8138 charset_roman
= CHARSET_FROM_ID (XINT (XCAR (val
))), val
= XCDR (val
);
8139 charset_big5
= CHARSET_FROM_ID (XINT (XCAR (val
)));
8142 charset
= charset_roman
;
8145 int b1
= c
>> 8, b2
= c
& 0x7F;
8146 if (b1
< 0xA1 || b1
> 0xFE
8147 || b2
< 0x40 || (b2
> 0x7E && b2
< 0xA1) || b2
> 0xFE)
8148 error ("Invalid code: %d", code
);
8149 charset
= charset_big5
;
8151 c
= DECODE_CHAR (charset
, (unsigned )c
);
8153 error ("Invalid code: %d", code
);
8154 return make_number (c
);
8157 DEFUN ("encode-big5-char", Fencode_big5_char
, Sencode_big5_char
, 1, 1, 0,
8158 doc
: /* Encode the Big5 character CHAR to BIG5 coding system.
8159 Return the corresponding character code in Big5. */)
8163 Lisp_Object spec
, attrs
, charset_list
;
8164 struct charset
*charset
;
8168 CHECK_CHARACTER (ch
);
8170 CHECK_CODING_SYSTEM_GET_SPEC (Vbig5_coding_system
, spec
);
8171 attrs
= AREF (spec
, 0);
8172 if (ASCII_CHAR_P (c
)
8173 && ! NILP (CODING_ATTR_ASCII_COMPAT (attrs
)))
8176 charset_list
= CODING_ATTR_CHARSET_LIST (attrs
);
8177 charset
= char_charset (c
, charset_list
, &code
);
8178 if (code
== CHARSET_INVALID_CODE (charset
))
8179 error ("Can't encode by Big5 encoding: %d", c
);
8181 return make_number (code
);
8185 DEFUN ("set-terminal-coding-system-internal",
8186 Fset_terminal_coding_system_internal
,
8187 Sset_terminal_coding_system_internal
, 1, 1, 0,
8188 doc
: /* Internal use only. */)
8190 Lisp_Object coding_system
;
8192 CHECK_SYMBOL (coding_system
);
8193 setup_coding_system (Fcheck_coding_system (coding_system
),
8196 /* We had better not send unsafe characters to terminal. */
8197 terminal_coding
.mode
|= CODING_MODE_SAFE_ENCODING
;
8198 /* Characer composition should be disabled. */
8199 terminal_coding
.common_flags
&= ~CODING_ANNOTATE_COMPOSITION_MASK
;
8200 terminal_coding
.src_multibyte
= 1;
8201 terminal_coding
.dst_multibyte
= 0;
8205 DEFUN ("set-safe-terminal-coding-system-internal",
8206 Fset_safe_terminal_coding_system_internal
,
8207 Sset_safe_terminal_coding_system_internal
, 1, 1, 0,
8208 doc
: /* Internal use only. */)
8210 Lisp_Object coding_system
;
8212 CHECK_SYMBOL (coding_system
);
8213 setup_coding_system (Fcheck_coding_system (coding_system
),
8214 &safe_terminal_coding
);
8215 /* Characer composition should be disabled. */
8216 safe_terminal_coding
.common_flags
&= ~CODING_ANNOTATE_COMPOSITION_MASK
;
8217 safe_terminal_coding
.src_multibyte
= 1;
8218 safe_terminal_coding
.dst_multibyte
= 0;
8222 DEFUN ("terminal-coding-system",
8223 Fterminal_coding_system
, Sterminal_coding_system
, 0, 0, 0,
8224 doc
: /* Return coding system specified for terminal output. */)
8227 Lisp_Object coding_system
;
8229 coding_system
= CODING_ID_NAME (terminal_coding
.id
);
8230 /* For backward compatibility, return nil if it is `undecided'. */
8231 return (coding_system
!= Qundecided
? coding_system
: Qnil
);
8234 DEFUN ("set-keyboard-coding-system-internal",
8235 Fset_keyboard_coding_system_internal
,
8236 Sset_keyboard_coding_system_internal
, 1, 1, 0,
8237 doc
: /* Internal use only. */)
8239 Lisp_Object coding_system
;
8241 CHECK_SYMBOL (coding_system
);
8242 setup_coding_system (Fcheck_coding_system (coding_system
),
8244 /* Characer composition should be disabled. */
8245 keyboard_coding
.common_flags
&= ~CODING_ANNOTATE_COMPOSITION_MASK
;
8249 DEFUN ("keyboard-coding-system",
8250 Fkeyboard_coding_system
, Skeyboard_coding_system
, 0, 0, 0,
8251 doc
: /* Return coding system specified for decoding keyboard input. */)
8254 return CODING_ID_NAME (keyboard_coding
.id
);
8258 DEFUN ("find-operation-coding-system", Ffind_operation_coding_system
,
8259 Sfind_operation_coding_system
, 1, MANY
, 0,
8260 doc
: /* Choose a coding system for an operation based on the target name.
8261 The value names a pair of coding systems: (DECODING-SYSTEM . ENCODING-SYSTEM).
8262 DECODING-SYSTEM is the coding system to use for decoding
8263 \(in case OPERATION does decoding), and ENCODING-SYSTEM is the coding system
8264 for encoding (in case OPERATION does encoding).
8266 The first argument OPERATION specifies an I/O primitive:
8267 For file I/O, `insert-file-contents' or `write-region'.
8268 For process I/O, `call-process', `call-process-region', or `start-process'.
8269 For network I/O, `open-network-stream'.
8271 The remaining arguments should be the same arguments that were passed
8272 to the primitive. Depending on which primitive, one of those arguments
8273 is selected as the TARGET. For example, if OPERATION does file I/O,
8274 whichever argument specifies the file name is TARGET.
8276 TARGET has a meaning which depends on OPERATION:
8277 For file I/O, TARGET is a file name.
8278 For process I/O, TARGET is a process name.
8279 For network I/O, TARGET is a service name or a port number
8281 This function looks up what specified for TARGET in,
8282 `file-coding-system-alist', `process-coding-system-alist',
8283 or `network-coding-system-alist' depending on OPERATION.
8284 They may specify a coding system, a cons of coding systems,
8285 or a function symbol to call.
8286 In the last case, we call the function with one argument,
8287 which is a list of all the arguments given to this function.
8289 usage: (find-operation-coding-system OPERATION ARGUMENTS ...) */)
8294 Lisp_Object operation
, target_idx
, target
, val
;
8295 register Lisp_Object chain
;
8298 error ("Too few arguments");
8299 operation
= args
[0];
8300 if (!SYMBOLP (operation
)
8301 || !INTEGERP (target_idx
= Fget (operation
, Qtarget_idx
)))
8302 error ("Invalid first arguement");
8303 if (nargs
< 1 + XINT (target_idx
))
8304 error ("Too few arguments for operation: %s",
8305 SDATA (SYMBOL_NAME (operation
)));
8306 target
= args
[XINT (target_idx
) + 1];
8307 if (!(STRINGP (target
)
8308 || (EQ (operation
, Qopen_network_stream
) && INTEGERP (target
))))
8309 error ("Invalid %dth argument", XINT (target_idx
) + 1);
8311 chain
= ((EQ (operation
, Qinsert_file_contents
)
8312 || EQ (operation
, Qwrite_region
))
8313 ? Vfile_coding_system_alist
8314 : (EQ (operation
, Qopen_network_stream
)
8315 ? Vnetwork_coding_system_alist
8316 : Vprocess_coding_system_alist
));
8320 for (; CONSP (chain
); chain
= XCDR (chain
))
8326 && ((STRINGP (target
)
8327 && STRINGP (XCAR (elt
))
8328 && fast_string_match (XCAR (elt
), target
) >= 0)
8329 || (INTEGERP (target
) && EQ (target
, XCAR (elt
)))))
8332 /* Here, if VAL is both a valid coding system and a valid
8333 function symbol, we return VAL as a coding system. */
8336 if (! SYMBOLP (val
))
8338 if (! NILP (Fcoding_system_p (val
)))
8339 return Fcons (val
, val
);
8340 if (! NILP (Ffboundp (val
)))
8342 val
= call1 (val
, Flist (nargs
, args
));
8345 if (SYMBOLP (val
) && ! NILP (Fcoding_system_p (val
)))
8346 return Fcons (val
, val
);
8354 DEFUN ("set-coding-system-priority", Fset_coding_system_priority
,
8355 Sset_coding_system_priority
, 0, MANY
, 0,
8356 doc
: /* Assign higher priority to the coding systems given as arguments.
8357 If multiple coding systems belongs to the same category,
8358 all but the first one are ignored.
8360 usage: (set-coding-system-priority ...) */)
8366 int changed
[coding_category_max
];
8367 enum coding_category priorities
[coding_category_max
];
8369 bzero (changed
, sizeof changed
);
8371 for (i
= j
= 0; i
< nargs
; i
++)
8373 enum coding_category category
;
8374 Lisp_Object spec
, attrs
;
8376 CHECK_CODING_SYSTEM_GET_SPEC (args
[i
], spec
);
8377 attrs
= AREF (spec
, 0);
8378 category
= XINT (CODING_ATTR_CATEGORY (attrs
));
8379 if (changed
[category
])
8380 /* Ignore this coding system because a coding system of the
8381 same category already had a higher priority. */
8383 changed
[category
] = 1;
8384 priorities
[j
++] = category
;
8385 if (coding_categories
[category
].id
>= 0
8386 && ! EQ (args
[i
], CODING_ID_NAME (coding_categories
[category
].id
)))
8387 setup_coding_system (args
[i
], &coding_categories
[category
]);
8388 Fset (AREF (Vcoding_category_table
, category
), args
[i
]);
8391 /* Now we have decided top J priorities. Reflect the order of the
8392 original priorities to the remaining priorities. */
8394 for (i
= j
, j
= 0; i
< coding_category_max
; i
++, j
++)
8396 while (j
< coding_category_max
8397 && changed
[coding_priorities
[j
]])
8399 if (j
== coding_category_max
)
8401 priorities
[i
] = coding_priorities
[j
];
8404 bcopy (priorities
, coding_priorities
, sizeof priorities
);
8406 /* Update `coding-category-list'. */
8407 Vcoding_category_list
= Qnil
;
8408 for (i
= coding_category_max
- 1; i
>= 0; i
--)
8409 Vcoding_category_list
8410 = Fcons (AREF (Vcoding_category_table
, priorities
[i
]),
8411 Vcoding_category_list
);
8416 DEFUN ("coding-system-priority-list", Fcoding_system_priority_list
,
8417 Scoding_system_priority_list
, 0, 1, 0,
8418 doc
: /* Return a list of coding systems ordered by their priorities.
8419 HIGHESTP non-nil means just return the highest priority one. */)
8421 Lisp_Object highestp
;
8426 for (i
= 0, val
= Qnil
; i
< coding_category_max
; i
++)
8428 enum coding_category category
= coding_priorities
[i
];
8429 int id
= coding_categories
[category
].id
;
8434 attrs
= CODING_ID_ATTRS (id
);
8435 if (! NILP (highestp
))
8436 return CODING_ATTR_BASE_NAME (attrs
);
8437 val
= Fcons (CODING_ATTR_BASE_NAME (attrs
), val
);
8439 return Fnreverse (val
);
8442 static char *suffixes
[] = { "-unix", "-dos", "-mac" };
8445 make_subsidiaries (base
)
8448 Lisp_Object subsidiaries
;
8449 int base_name_len
= SBYTES (SYMBOL_NAME (base
));
8450 char *buf
= (char *) alloca (base_name_len
+ 6);
8453 bcopy (SDATA (SYMBOL_NAME (base
)), buf
, base_name_len
);
8454 subsidiaries
= Fmake_vector (make_number (3), Qnil
);
8455 for (i
= 0; i
< 3; i
++)
8457 bcopy (suffixes
[i
], buf
+ base_name_len
, strlen (suffixes
[i
]) + 1);
8458 ASET (subsidiaries
, i
, intern (buf
));
8460 return subsidiaries
;
8464 DEFUN ("define-coding-system-internal", Fdefine_coding_system_internal
,
8465 Sdefine_coding_system_internal
, coding_arg_max
, MANY
, 0,
8466 doc
: /* For internal use only.
8467 usage: (define-coding-system-internal ...) */)
8473 Lisp_Object spec_vec
; /* [ ATTRS ALIASE EOL_TYPE ] */
8474 Lisp_Object attrs
; /* Vector of attributes. */
8475 Lisp_Object eol_type
;
8476 Lisp_Object aliases
;
8477 Lisp_Object coding_type
, charset_list
, safe_charsets
;
8478 enum coding_category category
;
8479 Lisp_Object tail
, val
;
8480 int max_charset_id
= 0;
8483 if (nargs
< coding_arg_max
)
8486 attrs
= Fmake_vector (make_number (coding_attr_last_index
), Qnil
);
8488 name
= args
[coding_arg_name
];
8489 CHECK_SYMBOL (name
);
8490 CODING_ATTR_BASE_NAME (attrs
) = name
;
8492 val
= args
[coding_arg_mnemonic
];
8493 if (! STRINGP (val
))
8494 CHECK_CHARACTER (val
);
8495 CODING_ATTR_MNEMONIC (attrs
) = val
;
8497 coding_type
= args
[coding_arg_coding_type
];
8498 CHECK_SYMBOL (coding_type
);
8499 CODING_ATTR_TYPE (attrs
) = coding_type
;
8501 charset_list
= args
[coding_arg_charset_list
];
8502 if (SYMBOLP (charset_list
))
8504 if (EQ (charset_list
, Qiso_2022
))
8506 if (! EQ (coding_type
, Qiso_2022
))
8507 error ("Invalid charset-list");
8508 charset_list
= Viso_2022_charset_list
;
8510 else if (EQ (charset_list
, Qemacs_mule
))
8512 if (! EQ (coding_type
, Qemacs_mule
))
8513 error ("Invalid charset-list");
8514 charset_list
= Vemacs_mule_charset_list
;
8516 for (tail
= charset_list
; CONSP (tail
); tail
= XCDR (tail
))
8517 if (max_charset_id
< XFASTINT (XCAR (tail
)))
8518 max_charset_id
= XFASTINT (XCAR (tail
));
8522 charset_list
= Fcopy_sequence (charset_list
);
8523 for (tail
= charset_list
; !NILP (tail
); tail
= Fcdr (tail
))
8525 struct charset
*charset
;
8528 CHECK_CHARSET_GET_CHARSET (val
, charset
);
8529 if (EQ (coding_type
, Qiso_2022
)
8530 ? CHARSET_ISO_FINAL (charset
) < 0
8531 : EQ (coding_type
, Qemacs_mule
)
8532 ? CHARSET_EMACS_MULE_ID (charset
) < 0
8534 error ("Can't handle charset `%s'",
8535 SDATA (SYMBOL_NAME (CHARSET_NAME (charset
))));
8537 XSETCAR (tail
, make_number (charset
->id
));
8538 if (max_charset_id
< charset
->id
)
8539 max_charset_id
= charset
->id
;
8542 CODING_ATTR_CHARSET_LIST (attrs
) = charset_list
;
8544 safe_charsets
= Fmake_string (make_number (max_charset_id
+ 1),
8546 for (tail
= charset_list
; CONSP (tail
); tail
= XCDR (tail
))
8547 SSET (safe_charsets
, XFASTINT (XCAR (tail
)), 0);
8548 CODING_ATTR_SAFE_CHARSETS (attrs
) = safe_charsets
;
8550 CODING_ATTR_ASCII_COMPAT (attrs
) = args
[coding_arg_ascii_compatible_p
];
8552 val
= args
[coding_arg_decode_translation_table
];
8553 if (! CHAR_TABLE_P (val
) && ! CONSP (val
))
8555 CODING_ATTR_DECODE_TBL (attrs
) = val
;
8557 val
= args
[coding_arg_encode_translation_table
];
8558 if (! CHAR_TABLE_P (val
) && ! CONSP (val
))
8560 CODING_ATTR_ENCODE_TBL (attrs
) = val
;
8562 val
= args
[coding_arg_post_read_conversion
];
8564 CODING_ATTR_POST_READ (attrs
) = val
;
8566 val
= args
[coding_arg_pre_write_conversion
];
8568 CODING_ATTR_PRE_WRITE (attrs
) = val
;
8570 val
= args
[coding_arg_default_char
];
8572 CODING_ATTR_DEFAULT_CHAR (attrs
) = make_number (' ');
8575 CHECK_CHARACTER (val
);
8576 CODING_ATTR_DEFAULT_CHAR (attrs
) = val
;
8579 val
= args
[coding_arg_for_unibyte
];
8580 CODING_ATTR_FOR_UNIBYTE (attrs
) = NILP (val
) ? Qnil
: Qt
;
8582 val
= args
[coding_arg_plist
];
8584 CODING_ATTR_PLIST (attrs
) = val
;
8586 if (EQ (coding_type
, Qcharset
))
8588 /* Generate a lisp vector of 256 elements. Each element is nil,
8589 integer, or a list of charset IDs.
8591 If Nth element is nil, the byte code N is invalid in this
8594 If Nth element is a number NUM, N is the first byte of a
8595 charset whose ID is NUM.
8597 If Nth element is a list of charset IDs, N is the first byte
8598 of one of them. The list is sorted by dimensions of the
8599 charsets. A charset of smaller dimension comes firtst. */
8600 val
= Fmake_vector (make_number (256), Qnil
);
8602 for (tail
= charset_list
; CONSP (tail
); tail
= XCDR (tail
))
8604 struct charset
*charset
= CHARSET_FROM_ID (XFASTINT (XCAR (tail
)));
8605 int dim
= CHARSET_DIMENSION (charset
);
8606 int idx
= (dim
- 1) * 4;
8608 if (CHARSET_ASCII_COMPATIBLE_P (charset
))
8609 CODING_ATTR_ASCII_COMPAT (attrs
) = Qt
;
8611 for (i
= charset
->code_space
[idx
];
8612 i
<= charset
->code_space
[idx
+ 1]; i
++)
8614 Lisp_Object tmp
, tmp2
;
8617 tmp
= AREF (val
, i
);
8620 else if (NUMBERP (tmp
))
8622 dim2
= CHARSET_DIMENSION (CHARSET_FROM_ID (XFASTINT (tmp
)));
8624 tmp
= Fcons (XCAR (tail
), Fcons (tmp
, Qnil
));
8626 tmp
= Fcons (tmp
, Fcons (XCAR (tail
), Qnil
));
8630 for (tmp2
= tmp
; CONSP (tmp2
); tmp2
= XCDR (tmp2
))
8632 dim2
= CHARSET_DIMENSION (CHARSET_FROM_ID (XFASTINT (XCAR (tmp2
))));
8637 tmp
= nconc2 (tmp
, Fcons (XCAR (tail
), Qnil
));
8640 XSETCDR (tmp2
, Fcons (XCAR (tmp2
), XCDR (tmp2
)));
8641 XSETCAR (tmp2
, XCAR (tail
));
8647 ASET (attrs
, coding_attr_charset_valids
, val
);
8648 category
= coding_category_charset
;
8650 else if (EQ (coding_type
, Qccl
))
8654 if (nargs
< coding_arg_ccl_max
)
8657 val
= args
[coding_arg_ccl_decoder
];
8658 CHECK_CCL_PROGRAM (val
);
8660 val
= Fcopy_sequence (val
);
8661 ASET (attrs
, coding_attr_ccl_decoder
, val
);
8663 val
= args
[coding_arg_ccl_encoder
];
8664 CHECK_CCL_PROGRAM (val
);
8666 val
= Fcopy_sequence (val
);
8667 ASET (attrs
, coding_attr_ccl_encoder
, val
);
8669 val
= args
[coding_arg_ccl_valids
];
8670 valids
= Fmake_string (make_number (256), make_number (0));
8671 for (tail
= val
; !NILP (tail
); tail
= Fcdr (tail
))
8678 from
= to
= XINT (val
);
8679 if (from
< 0 || from
> 255)
8680 args_out_of_range_3 (val
, make_number (0), make_number (255));
8685 CHECK_NATNUM_CAR (val
);
8686 CHECK_NATNUM_CDR (val
);
8687 from
= XINT (XCAR (val
));
8689 args_out_of_range_3 (XCAR (val
),
8690 make_number (0), make_number (255));
8691 to
= XINT (XCDR (val
));
8692 if (to
< from
|| to
> 255)
8693 args_out_of_range_3 (XCDR (val
),
8694 XCAR (val
), make_number (255));
8696 for (i
= from
; i
<= to
; i
++)
8697 SSET (valids
, i
, 1);
8699 ASET (attrs
, coding_attr_ccl_valids
, valids
);
8701 category
= coding_category_ccl
;
8703 else if (EQ (coding_type
, Qutf_16
))
8705 Lisp_Object bom
, endian
;
8707 CODING_ATTR_ASCII_COMPAT (attrs
) = Qnil
;
8709 if (nargs
< coding_arg_utf16_max
)
8712 bom
= args
[coding_arg_utf16_bom
];
8713 if (! NILP (bom
) && ! EQ (bom
, Qt
))
8717 CHECK_CODING_SYSTEM (val
);
8719 CHECK_CODING_SYSTEM (val
);
8721 ASET (attrs
, coding_attr_utf_16_bom
, bom
);
8723 endian
= args
[coding_arg_utf16_endian
];
8724 CHECK_SYMBOL (endian
);
8727 else if (! EQ (endian
, Qbig
) && ! EQ (endian
, Qlittle
))
8728 error ("Invalid endian: %s", SDATA (SYMBOL_NAME (endian
)));
8729 ASET (attrs
, coding_attr_utf_16_endian
, endian
);
8731 category
= (CONSP (bom
)
8732 ? coding_category_utf_16_auto
8734 ? (EQ (endian
, Qbig
)
8735 ? coding_category_utf_16_be_nosig
8736 : coding_category_utf_16_le_nosig
)
8737 : (EQ (endian
, Qbig
)
8738 ? coding_category_utf_16_be
8739 : coding_category_utf_16_le
));
8741 else if (EQ (coding_type
, Qiso_2022
))
8743 Lisp_Object initial
, reg_usage
, request
, flags
;
8746 if (nargs
< coding_arg_iso2022_max
)
8749 initial
= Fcopy_sequence (args
[coding_arg_iso2022_initial
]);
8750 CHECK_VECTOR (initial
);
8751 for (i
= 0; i
< 4; i
++)
8753 val
= Faref (initial
, make_number (i
));
8756 struct charset
*charset
;
8758 CHECK_CHARSET_GET_CHARSET (val
, charset
);
8759 ASET (initial
, i
, make_number (CHARSET_ID (charset
)));
8760 if (i
== 0 && CHARSET_ASCII_COMPATIBLE_P (charset
))
8761 CODING_ATTR_ASCII_COMPAT (attrs
) = Qt
;
8764 ASET (initial
, i
, make_number (-1));
8767 reg_usage
= args
[coding_arg_iso2022_reg_usage
];
8768 CHECK_CONS (reg_usage
);
8769 CHECK_NUMBER_CAR (reg_usage
);
8770 CHECK_NUMBER_CDR (reg_usage
);
8772 request
= Fcopy_sequence (args
[coding_arg_iso2022_request
]);
8773 for (tail
= request
; ! NILP (tail
); tail
= Fcdr (tail
))
8781 CHECK_CHARSET_GET_ID (tmp
, id
);
8782 CHECK_NATNUM_CDR (val
);
8783 if (XINT (XCDR (val
)) >= 4)
8784 error ("Invalid graphic register number: %d", XINT (XCDR (val
)));
8785 XSETCAR (val
, make_number (id
));
8788 flags
= args
[coding_arg_iso2022_flags
];
8789 CHECK_NATNUM (flags
);
8791 if (EQ (args
[coding_arg_charset_list
], Qiso_2022
))
8792 flags
= make_number (i
| CODING_ISO_FLAG_FULL_SUPPORT
);
8794 ASET (attrs
, coding_attr_iso_initial
, initial
);
8795 ASET (attrs
, coding_attr_iso_usage
, reg_usage
);
8796 ASET (attrs
, coding_attr_iso_request
, request
);
8797 ASET (attrs
, coding_attr_iso_flags
, flags
);
8798 setup_iso_safe_charsets (attrs
);
8800 if (i
& CODING_ISO_FLAG_SEVEN_BITS
)
8801 category
= ((i
& (CODING_ISO_FLAG_LOCKING_SHIFT
8802 | CODING_ISO_FLAG_SINGLE_SHIFT
))
8803 ? coding_category_iso_7_else
8804 : EQ (args
[coding_arg_charset_list
], Qiso_2022
)
8805 ? coding_category_iso_7
8806 : coding_category_iso_7_tight
);
8809 int id
= XINT (AREF (initial
, 1));
8811 category
= (((i
& CODING_ISO_FLAG_LOCKING_SHIFT
)
8812 || EQ (args
[coding_arg_charset_list
], Qiso_2022
)
8814 ? coding_category_iso_8_else
8815 : (CHARSET_DIMENSION (CHARSET_FROM_ID (id
)) == 1)
8816 ? coding_category_iso_8_1
8817 : coding_category_iso_8_2
);
8819 if (category
!= coding_category_iso_8_1
8820 && category
!= coding_category_iso_8_2
)
8821 CODING_ATTR_ASCII_COMPAT (attrs
) = Qnil
;
8823 else if (EQ (coding_type
, Qemacs_mule
))
8825 if (EQ (args
[coding_arg_charset_list
], Qemacs_mule
))
8826 ASET (attrs
, coding_attr_emacs_mule_full
, Qt
);
8827 CODING_ATTR_ASCII_COMPAT (attrs
) = Qt
;
8828 category
= coding_category_emacs_mule
;
8830 else if (EQ (coding_type
, Qshift_jis
))
8833 struct charset
*charset
;
8835 if (XINT (Flength (charset_list
)) != 3
8836 && XINT (Flength (charset_list
)) != 4)
8837 error ("There should be three or four charsets");
8839 charset
= CHARSET_FROM_ID (XINT (XCAR (charset_list
)));
8840 if (CHARSET_DIMENSION (charset
) != 1)
8841 error ("Dimension of charset %s is not one",
8842 SDATA (SYMBOL_NAME (CHARSET_NAME (charset
))));
8843 if (CHARSET_ASCII_COMPATIBLE_P (charset
))
8844 CODING_ATTR_ASCII_COMPAT (attrs
) = Qt
;
8846 charset_list
= XCDR (charset_list
);
8847 charset
= CHARSET_FROM_ID (XINT (XCAR (charset_list
)));
8848 if (CHARSET_DIMENSION (charset
) != 1)
8849 error ("Dimension of charset %s is not one",
8850 SDATA (SYMBOL_NAME (CHARSET_NAME (charset
))));
8852 charset_list
= XCDR (charset_list
);
8853 charset
= CHARSET_FROM_ID (XINT (XCAR (charset_list
)));
8854 if (CHARSET_DIMENSION (charset
) != 2)
8855 error ("Dimension of charset %s is not two",
8856 SDATA (SYMBOL_NAME (CHARSET_NAME (charset
))));
8858 charset_list
= XCDR (charset_list
);
8859 if (! NILP (charset_list
))
8861 charset
= CHARSET_FROM_ID (XINT (XCAR (charset_list
)));
8862 if (CHARSET_DIMENSION (charset
) != 2)
8863 error ("Dimension of charset %s is not two",
8864 SDATA (SYMBOL_NAME (CHARSET_NAME (charset
))));
8867 category
= coding_category_sjis
;
8868 Vsjis_coding_system
= name
;
8870 else if (EQ (coding_type
, Qbig5
))
8872 struct charset
*charset
;
8874 if (XINT (Flength (charset_list
)) != 2)
8875 error ("There should be just two charsets");
8877 charset
= CHARSET_FROM_ID (XINT (XCAR (charset_list
)));
8878 if (CHARSET_DIMENSION (charset
) != 1)
8879 error ("Dimension of charset %s is not one",
8880 SDATA (SYMBOL_NAME (CHARSET_NAME (charset
))));
8881 if (CHARSET_ASCII_COMPATIBLE_P (charset
))
8882 CODING_ATTR_ASCII_COMPAT (attrs
) = Qt
;
8884 charset_list
= XCDR (charset_list
);
8885 charset
= CHARSET_FROM_ID (XINT (XCAR (charset_list
)));
8886 if (CHARSET_DIMENSION (charset
) != 2)
8887 error ("Dimension of charset %s is not two",
8888 SDATA (SYMBOL_NAME (CHARSET_NAME (charset
))));
8890 category
= coding_category_big5
;
8891 Vbig5_coding_system
= name
;
8893 else if (EQ (coding_type
, Qraw_text
))
8895 category
= coding_category_raw_text
;
8896 CODING_ATTR_ASCII_COMPAT (attrs
) = Qt
;
8898 else if (EQ (coding_type
, Qutf_8
))
8900 category
= coding_category_utf_8
;
8901 CODING_ATTR_ASCII_COMPAT (attrs
) = Qt
;
8903 else if (EQ (coding_type
, Qundecided
))
8904 category
= coding_category_undecided
;
8906 error ("Invalid coding system type: %s",
8907 SDATA (SYMBOL_NAME (coding_type
)));
8909 CODING_ATTR_CATEGORY (attrs
) = make_number (category
);
8910 CODING_ATTR_PLIST (attrs
)
8911 = Fcons (QCcategory
, Fcons (AREF (Vcoding_category_table
, category
),
8912 CODING_ATTR_PLIST (attrs
)));
8913 CODING_ATTR_PLIST (attrs
)
8914 = Fcons (QCascii_compatible_p
,
8915 Fcons (CODING_ATTR_ASCII_COMPAT (attrs
),
8916 CODING_ATTR_PLIST (attrs
)));
8918 eol_type
= args
[coding_arg_eol_type
];
8919 if (! NILP (eol_type
)
8920 && ! EQ (eol_type
, Qunix
)
8921 && ! EQ (eol_type
, Qdos
)
8922 && ! EQ (eol_type
, Qmac
))
8923 error ("Invalid eol-type");
8925 aliases
= Fcons (name
, Qnil
);
8927 if (NILP (eol_type
))
8929 eol_type
= make_subsidiaries (name
);
8930 for (i
= 0; i
< 3; i
++)
8932 Lisp_Object this_spec
, this_name
, this_aliases
, this_eol_type
;
8934 this_name
= AREF (eol_type
, i
);
8935 this_aliases
= Fcons (this_name
, Qnil
);
8936 this_eol_type
= (i
== 0 ? Qunix
: i
== 1 ? Qdos
: Qmac
);
8937 this_spec
= Fmake_vector (make_number (3), attrs
);
8938 ASET (this_spec
, 1, this_aliases
);
8939 ASET (this_spec
, 2, this_eol_type
);
8940 Fputhash (this_name
, this_spec
, Vcoding_system_hash_table
);
8941 Vcoding_system_list
= Fcons (this_name
, Vcoding_system_list
);
8942 val
= Fassoc (Fsymbol_name (this_name
), Vcoding_system_alist
);
8944 Vcoding_system_alist
8945 = Fcons (Fcons (Fsymbol_name (this_name
), Qnil
),
8946 Vcoding_system_alist
);
8950 spec_vec
= Fmake_vector (make_number (3), attrs
);
8951 ASET (spec_vec
, 1, aliases
);
8952 ASET (spec_vec
, 2, eol_type
);
8954 Fputhash (name
, spec_vec
, Vcoding_system_hash_table
);
8955 Vcoding_system_list
= Fcons (name
, Vcoding_system_list
);
8956 val
= Fassoc (Fsymbol_name (name
), Vcoding_system_alist
);
8958 Vcoding_system_alist
= Fcons (Fcons (Fsymbol_name (name
), Qnil
),
8959 Vcoding_system_alist
);
8962 int id
= coding_categories
[category
].id
;
8964 if (id
< 0 || EQ (name
, CODING_ID_NAME (id
)))
8965 setup_coding_system (name
, &coding_categories
[category
]);
8971 return Fsignal (Qwrong_number_of_arguments
,
8972 Fcons (intern ("define-coding-system-internal"),
8973 make_number (nargs
)));
8977 DEFUN ("coding-system-put", Fcoding_system_put
, Scoding_system_put
,
8979 doc
: /* Change value in CODING-SYSTEM's property list PROP to VAL. */)
8980 (coding_system
, prop
, val
)
8981 Lisp_Object coding_system
, prop
, val
;
8983 Lisp_Object spec
, attrs
;
8985 CHECK_CODING_SYSTEM_GET_SPEC (coding_system
, spec
);
8986 attrs
= AREF (spec
, 0);
8987 if (EQ (prop
, QCmnemonic
))
8989 if (! STRINGP (val
))
8990 CHECK_CHARACTER (val
);
8991 CODING_ATTR_MNEMONIC (attrs
) = val
;
8993 else if (EQ (prop
, QCdefalut_char
))
8996 val
= make_number (' ');
8998 CHECK_CHARACTER (val
);
8999 CODING_ATTR_DEFAULT_CHAR (attrs
) = val
;
9001 else if (EQ (prop
, QCdecode_translation_table
))
9003 if (! CHAR_TABLE_P (val
) && ! CONSP (val
))
9005 CODING_ATTR_DECODE_TBL (attrs
) = val
;
9007 else if (EQ (prop
, QCencode_translation_table
))
9009 if (! CHAR_TABLE_P (val
) && ! CONSP (val
))
9011 CODING_ATTR_ENCODE_TBL (attrs
) = val
;
9013 else if (EQ (prop
, QCpost_read_conversion
))
9016 CODING_ATTR_POST_READ (attrs
) = val
;
9018 else if (EQ (prop
, QCpre_write_conversion
))
9021 CODING_ATTR_PRE_WRITE (attrs
) = val
;
9023 else if (EQ (prop
, QCascii_compatible_p
))
9025 CODING_ATTR_ASCII_COMPAT (attrs
) = val
;
9028 CODING_ATTR_PLIST (attrs
)
9029 = Fplist_put (CODING_ATTR_PLIST (attrs
), prop
, val
);
9034 DEFUN ("define-coding-system-alias", Fdefine_coding_system_alias
,
9035 Sdefine_coding_system_alias
, 2, 2, 0,
9036 doc
: /* Define ALIAS as an alias for CODING-SYSTEM. */)
9037 (alias
, coding_system
)
9038 Lisp_Object alias
, coding_system
;
9040 Lisp_Object spec
, aliases
, eol_type
, val
;
9042 CHECK_SYMBOL (alias
);
9043 CHECK_CODING_SYSTEM_GET_SPEC (coding_system
, spec
);
9044 aliases
= AREF (spec
, 1);
9045 /* ALISES should be a list of length more than zero, and the first
9046 element is a base coding system. Append ALIAS at the tail of the
9048 while (!NILP (XCDR (aliases
)))
9049 aliases
= XCDR (aliases
);
9050 XSETCDR (aliases
, Fcons (alias
, Qnil
));
9052 eol_type
= AREF (spec
, 2);
9053 if (VECTORP (eol_type
))
9055 Lisp_Object subsidiaries
;
9058 subsidiaries
= make_subsidiaries (alias
);
9059 for (i
= 0; i
< 3; i
++)
9060 Fdefine_coding_system_alias (AREF (subsidiaries
, i
),
9061 AREF (eol_type
, i
));
9064 Fputhash (alias
, spec
, Vcoding_system_hash_table
);
9065 Vcoding_system_list
= Fcons (alias
, Vcoding_system_list
);
9066 val
= Fassoc (Fsymbol_name (alias
), Vcoding_system_alist
);
9068 Vcoding_system_alist
= Fcons (Fcons (Fsymbol_name (alias
), Qnil
),
9069 Vcoding_system_alist
);
9074 DEFUN ("coding-system-base", Fcoding_system_base
, Scoding_system_base
,
9076 doc
: /* Return the base of CODING-SYSTEM.
9077 Any alias or subsidiary coding system is not a base coding system. */)
9079 Lisp_Object coding_system
;
9081 Lisp_Object spec
, attrs
;
9083 if (NILP (coding_system
))
9084 return (Qno_conversion
);
9085 CHECK_CODING_SYSTEM_GET_SPEC (coding_system
, spec
);
9086 attrs
= AREF (spec
, 0);
9087 return CODING_ATTR_BASE_NAME (attrs
);
9090 DEFUN ("coding-system-plist", Fcoding_system_plist
, Scoding_system_plist
,
9092 doc
: "Return the property list of CODING-SYSTEM.")
9094 Lisp_Object coding_system
;
9096 Lisp_Object spec
, attrs
;
9098 if (NILP (coding_system
))
9099 coding_system
= Qno_conversion
;
9100 CHECK_CODING_SYSTEM_GET_SPEC (coding_system
, spec
);
9101 attrs
= AREF (spec
, 0);
9102 return CODING_ATTR_PLIST (attrs
);
9106 DEFUN ("coding-system-aliases", Fcoding_system_aliases
, Scoding_system_aliases
,
9108 doc
: /* Return the list of aliases of CODING-SYSTEM. */)
9110 Lisp_Object coding_system
;
9114 if (NILP (coding_system
))
9115 coding_system
= Qno_conversion
;
9116 CHECK_CODING_SYSTEM_GET_SPEC (coding_system
, spec
);
9117 return AREF (spec
, 1);
9120 DEFUN ("coding-system-eol-type", Fcoding_system_eol_type
,
9121 Scoding_system_eol_type
, 1, 1, 0,
9122 doc
: /* Return eol-type of CODING-SYSTEM.
9123 An eol-type is integer 0, 1, 2, or a vector of coding systems.
9125 Integer values 0, 1, and 2 indicate a format of end-of-line; LF, CRLF,
9126 and CR respectively.
9128 A vector value indicates that a format of end-of-line should be
9129 detected automatically. Nth element of the vector is the subsidiary
9130 coding system whose eol-type is N. */)
9132 Lisp_Object coding_system
;
9134 Lisp_Object spec
, eol_type
;
9137 if (NILP (coding_system
))
9138 coding_system
= Qno_conversion
;
9139 if (! CODING_SYSTEM_P (coding_system
))
9141 spec
= CODING_SYSTEM_SPEC (coding_system
);
9142 eol_type
= AREF (spec
, 2);
9143 if (VECTORP (eol_type
))
9144 return Fcopy_sequence (eol_type
);
9145 n
= EQ (eol_type
, Qunix
) ? 0 : EQ (eol_type
, Qdos
) ? 1 : 2;
9146 return make_number (n
);
9152 /*** 9. Post-amble ***/
9159 for (i
= 0; i
< coding_category_max
; i
++)
9161 coding_categories
[i
].id
= -1;
9162 coding_priorities
[i
] = i
;
9165 /* ISO2022 specific initialize routine. */
9166 for (i
= 0; i
< 0x20; i
++)
9167 iso_code_class
[i
] = ISO_control_0
;
9168 for (i
= 0x21; i
< 0x7F; i
++)
9169 iso_code_class
[i
] = ISO_graphic_plane_0
;
9170 for (i
= 0x80; i
< 0xA0; i
++)
9171 iso_code_class
[i
] = ISO_control_1
;
9172 for (i
= 0xA1; i
< 0xFF; i
++)
9173 iso_code_class
[i
] = ISO_graphic_plane_1
;
9174 iso_code_class
[0x20] = iso_code_class
[0x7F] = ISO_0x20_or_0x7F
;
9175 iso_code_class
[0xA0] = iso_code_class
[0xFF] = ISO_0xA0_or_0xFF
;
9176 iso_code_class
[ISO_CODE_SO
] = ISO_shift_out
;
9177 iso_code_class
[ISO_CODE_SI
] = ISO_shift_in
;
9178 iso_code_class
[ISO_CODE_SS2_7
] = ISO_single_shift_2_7
;
9179 iso_code_class
[ISO_CODE_ESC
] = ISO_escape
;
9180 iso_code_class
[ISO_CODE_SS2
] = ISO_single_shift_2
;
9181 iso_code_class
[ISO_CODE_SS3
] = ISO_single_shift_3
;
9182 iso_code_class
[ISO_CODE_CSI
] = ISO_control_sequence_introducer
;
9184 for (i
= 0; i
< 256; i
++)
9186 emacs_mule_bytes
[i
] = 1;
9188 emacs_mule_bytes
[EMACS_MULE_LEADING_CODE_PRIVATE_11
] = 3;
9189 emacs_mule_bytes
[EMACS_MULE_LEADING_CODE_PRIVATE_12
] = 3;
9190 emacs_mule_bytes
[EMACS_MULE_LEADING_CODE_PRIVATE_21
] = 4;
9191 emacs_mule_bytes
[EMACS_MULE_LEADING_CODE_PRIVATE_22
] = 4;
9199 staticpro (&Vcoding_system_hash_table
);
9201 Lisp_Object args
[2];
9204 Vcoding_system_hash_table
= Fmake_hash_table (2, args
);
9207 staticpro (&Vsjis_coding_system
);
9208 Vsjis_coding_system
= Qnil
;
9210 staticpro (&Vbig5_coding_system
);
9211 Vbig5_coding_system
= Qnil
;
9213 staticpro (&Vcode_conversion_reused_workbuf
);
9214 Vcode_conversion_reused_workbuf
= Qnil
;
9216 staticpro (&Vcode_conversion_workbuf_name
);
9217 Vcode_conversion_workbuf_name
= build_string (" *code-conversion-work*");
9219 reused_workbuf_in_use
= 0;
9221 DEFSYM (Qcharset
, "charset");
9222 DEFSYM (Qtarget_idx
, "target-idx");
9223 DEFSYM (Qcoding_system_history
, "coding-system-history");
9224 Fset (Qcoding_system_history
, Qnil
);
9226 /* Target FILENAME is the first argument. */
9227 Fput (Qinsert_file_contents
, Qtarget_idx
, make_number (0));
9228 /* Target FILENAME is the third argument. */
9229 Fput (Qwrite_region
, Qtarget_idx
, make_number (2));
9231 DEFSYM (Qcall_process
, "call-process");
9232 /* Target PROGRAM is the first argument. */
9233 Fput (Qcall_process
, Qtarget_idx
, make_number (0));
9235 DEFSYM (Qcall_process_region
, "call-process-region");
9236 /* Target PROGRAM is the third argument. */
9237 Fput (Qcall_process_region
, Qtarget_idx
, make_number (2));
9239 DEFSYM (Qstart_process
, "start-process");
9240 /* Target PROGRAM is the third argument. */
9241 Fput (Qstart_process
, Qtarget_idx
, make_number (2));
9243 DEFSYM (Qopen_network_stream
, "open-network-stream");
9244 /* Target SERVICE is the fourth argument. */
9245 Fput (Qopen_network_stream
, Qtarget_idx
, make_number (3));
9247 DEFSYM (Qcoding_system
, "coding-system");
9248 DEFSYM (Qcoding_aliases
, "coding-aliases");
9250 DEFSYM (Qeol_type
, "eol-type");
9251 DEFSYM (Qunix
, "unix");
9252 DEFSYM (Qdos
, "dos");
9254 DEFSYM (Qbuffer_file_coding_system
, "buffer-file-coding-system");
9255 DEFSYM (Qpost_read_conversion
, "post-read-conversion");
9256 DEFSYM (Qpre_write_conversion
, "pre-write-conversion");
9257 DEFSYM (Qdefault_char
, "default-char");
9258 DEFSYM (Qundecided
, "undecided");
9259 DEFSYM (Qno_conversion
, "no-conversion");
9260 DEFSYM (Qraw_text
, "raw-text");
9262 DEFSYM (Qiso_2022
, "iso-2022");
9264 DEFSYM (Qutf_8
, "utf-8");
9265 DEFSYM (Qutf_8_emacs
, "utf-8-emacs");
9267 DEFSYM (Qutf_16
, "utf-16");
9268 DEFSYM (Qbig
, "big");
9269 DEFSYM (Qlittle
, "little");
9271 DEFSYM (Qshift_jis
, "shift-jis");
9272 DEFSYM (Qbig5
, "big5");
9274 DEFSYM (Qcoding_system_p
, "coding-system-p");
9276 DEFSYM (Qcoding_system_error
, "coding-system-error");
9277 Fput (Qcoding_system_error
, Qerror_conditions
,
9278 Fcons (Qcoding_system_error
, Fcons (Qerror
, Qnil
)));
9279 Fput (Qcoding_system_error
, Qerror_message
,
9280 build_string ("Invalid coding system"));
9282 /* Intern this now in case it isn't already done.
9283 Setting this variable twice is harmless.
9284 But don't staticpro it here--that is done in alloc.c. */
9285 Qchar_table_extra_slots
= intern ("char-table-extra-slots");
9287 DEFSYM (Qtranslation_table
, "translation-table");
9288 Fput (Qtranslation_table
, Qchar_table_extra_slots
, make_number (2));
9289 DEFSYM (Qtranslation_table_id
, "translation-table-id");
9290 DEFSYM (Qtranslation_table_for_decode
, "translation-table-for-decode");
9291 DEFSYM (Qtranslation_table_for_encode
, "translation-table-for-encode");
9293 DEFSYM (Qvalid_codes
, "valid-codes");
9295 DEFSYM (Qemacs_mule
, "emacs-mule");
9297 DEFSYM (QCcategory
, ":category");
9298 DEFSYM (QCmnemonic
, ":mnemonic");
9299 DEFSYM (QCdefalut_char
, ":default-char");
9300 DEFSYM (QCdecode_translation_table
, ":decode-translation-table");
9301 DEFSYM (QCencode_translation_table
, ":encode-translation-table");
9302 DEFSYM (QCpost_read_conversion
, ":post-read-conversion");
9303 DEFSYM (QCpre_write_conversion
, ":pre-write-conversion");
9304 DEFSYM (QCascii_compatible_p
, ":ascii-compatible-p");
9306 Vcoding_category_table
9307 = Fmake_vector (make_number (coding_category_max
), Qnil
);
9308 staticpro (&Vcoding_category_table
);
9309 /* Followings are target of code detection. */
9310 ASET (Vcoding_category_table
, coding_category_iso_7
,
9311 intern ("coding-category-iso-7"));
9312 ASET (Vcoding_category_table
, coding_category_iso_7_tight
,
9313 intern ("coding-category-iso-7-tight"));
9314 ASET (Vcoding_category_table
, coding_category_iso_8_1
,
9315 intern ("coding-category-iso-8-1"));
9316 ASET (Vcoding_category_table
, coding_category_iso_8_2
,
9317 intern ("coding-category-iso-8-2"));
9318 ASET (Vcoding_category_table
, coding_category_iso_7_else
,
9319 intern ("coding-category-iso-7-else"));
9320 ASET (Vcoding_category_table
, coding_category_iso_8_else
,
9321 intern ("coding-category-iso-8-else"));
9322 ASET (Vcoding_category_table
, coding_category_utf_8
,
9323 intern ("coding-category-utf-8"));
9324 ASET (Vcoding_category_table
, coding_category_utf_16_be
,
9325 intern ("coding-category-utf-16-be"));
9326 ASET (Vcoding_category_table
, coding_category_utf_16_auto
,
9327 intern ("coding-category-utf-16-auto"));
9328 ASET (Vcoding_category_table
, coding_category_utf_16_le
,
9329 intern ("coding-category-utf-16-le"));
9330 ASET (Vcoding_category_table
, coding_category_utf_16_be_nosig
,
9331 intern ("coding-category-utf-16-be-nosig"));
9332 ASET (Vcoding_category_table
, coding_category_utf_16_le_nosig
,
9333 intern ("coding-category-utf-16-le-nosig"));
9334 ASET (Vcoding_category_table
, coding_category_charset
,
9335 intern ("coding-category-charset"));
9336 ASET (Vcoding_category_table
, coding_category_sjis
,
9337 intern ("coding-category-sjis"));
9338 ASET (Vcoding_category_table
, coding_category_big5
,
9339 intern ("coding-category-big5"));
9340 ASET (Vcoding_category_table
, coding_category_ccl
,
9341 intern ("coding-category-ccl"));
9342 ASET (Vcoding_category_table
, coding_category_emacs_mule
,
9343 intern ("coding-category-emacs-mule"));
9344 /* Followings are NOT target of code detection. */
9345 ASET (Vcoding_category_table
, coding_category_raw_text
,
9346 intern ("coding-category-raw-text"));
9347 ASET (Vcoding_category_table
, coding_category_undecided
,
9348 intern ("coding-category-undecided"));
9350 DEFSYM (Qinsufficient_source
, "insufficient-source");
9351 DEFSYM (Qinconsistent_eol
, "inconsistent-eol");
9352 DEFSYM (Qinvalid_source
, "invalid-source");
9353 DEFSYM (Qinterrupted
, "interrupted");
9354 DEFSYM (Qinsufficient_memory
, "insufficient-memory");
9355 DEFSYM (Qcoding_system_define_form
, "coding-system-define-form");
9357 defsubr (&Scoding_system_p
);
9358 defsubr (&Sread_coding_system
);
9359 defsubr (&Sread_non_nil_coding_system
);
9360 defsubr (&Scheck_coding_system
);
9361 defsubr (&Sdetect_coding_region
);
9362 defsubr (&Sdetect_coding_string
);
9363 defsubr (&Sfind_coding_systems_region_internal
);
9364 defsubr (&Sunencodable_char_position
);
9365 defsubr (&Scheck_coding_systems_region
);
9366 defsubr (&Sdecode_coding_region
);
9367 defsubr (&Sencode_coding_region
);
9368 defsubr (&Sdecode_coding_string
);
9369 defsubr (&Sencode_coding_string
);
9370 defsubr (&Sdecode_sjis_char
);
9371 defsubr (&Sencode_sjis_char
);
9372 defsubr (&Sdecode_big5_char
);
9373 defsubr (&Sencode_big5_char
);
9374 defsubr (&Sset_terminal_coding_system_internal
);
9375 defsubr (&Sset_safe_terminal_coding_system_internal
);
9376 defsubr (&Sterminal_coding_system
);
9377 defsubr (&Sset_keyboard_coding_system_internal
);
9378 defsubr (&Skeyboard_coding_system
);
9379 defsubr (&Sfind_operation_coding_system
);
9380 defsubr (&Sset_coding_system_priority
);
9381 defsubr (&Sdefine_coding_system_internal
);
9382 defsubr (&Sdefine_coding_system_alias
);
9383 defsubr (&Scoding_system_put
);
9384 defsubr (&Scoding_system_base
);
9385 defsubr (&Scoding_system_plist
);
9386 defsubr (&Scoding_system_aliases
);
9387 defsubr (&Scoding_system_eol_type
);
9388 defsubr (&Scoding_system_priority_list
);
9390 DEFVAR_LISP ("coding-system-list", &Vcoding_system_list
,
9391 doc
: /* List of coding systems.
9393 Do not alter the value of this variable manually. This variable should be
9394 updated by the functions `define-coding-system' and
9395 `define-coding-system-alias'. */);
9396 Vcoding_system_list
= Qnil
;
9398 DEFVAR_LISP ("coding-system-alist", &Vcoding_system_alist
,
9399 doc
: /* Alist of coding system names.
9400 Each element is one element list of coding system name.
9401 This variable is given to `completing-read' as TABLE argument.
9403 Do not alter the value of this variable manually. This variable should be
9404 updated by the functions `make-coding-system' and
9405 `define-coding-system-alias'. */);
9406 Vcoding_system_alist
= Qnil
;
9408 DEFVAR_LISP ("coding-category-list", &Vcoding_category_list
,
9409 doc
: /* List of coding-categories (symbols) ordered by priority.
9411 On detecting a coding system, Emacs tries code detection algorithms
9412 associated with each coding-category one by one in this order. When
9413 one algorithm agrees with a byte sequence of source text, the coding
9414 system bound to the corresponding coding-category is selected.
9416 Don't modify this variable directly, but use `set-coding-priority'. */);
9420 Vcoding_category_list
= Qnil
;
9421 for (i
= coding_category_max
- 1; i
>= 0; i
--)
9422 Vcoding_category_list
9423 = Fcons (XVECTOR (Vcoding_category_table
)->contents
[i
],
9424 Vcoding_category_list
);
9427 DEFVAR_LISP ("coding-system-for-read", &Vcoding_system_for_read
,
9428 doc
: /* Specify the coding system for read operations.
9429 It is useful to bind this variable with `let', but do not set it globally.
9430 If the value is a coding system, it is used for decoding on read operation.
9431 If not, an appropriate element is used from one of the coding system alists:
9432 There are three such tables, `file-coding-system-alist',
9433 `process-coding-system-alist', and `network-coding-system-alist'. */);
9434 Vcoding_system_for_read
= Qnil
;
9436 DEFVAR_LISP ("coding-system-for-write", &Vcoding_system_for_write
,
9437 doc
: /* Specify the coding system for write operations.
9438 Programs bind this variable with `let', but you should not set it globally.
9439 If the value is a coding system, it is used for encoding of output,
9440 when writing it to a file and when sending it to a file or subprocess.
9442 If this does not specify a coding system, an appropriate element
9443 is used from one of the coding system alists:
9444 There are three such tables, `file-coding-system-alist',
9445 `process-coding-system-alist', and `network-coding-system-alist'.
9446 For output to files, if the above procedure does not specify a coding system,
9447 the value of `buffer-file-coding-system' is used. */);
9448 Vcoding_system_for_write
= Qnil
;
9450 DEFVAR_LISP ("last-coding-system-used", &Vlast_coding_system_used
,
9452 Coding system used in the latest file or process I/O. */);
9453 Vlast_coding_system_used
= Qnil
;
9455 DEFVAR_LISP ("last-code-conversion-error", &Vlast_code_conversion_error
,
9457 Error status of the last code conversion.
9459 When an error was detected in the last code conversion, this variable
9460 is set to one of the following symbols.
9461 `insufficient-source'
9465 `insufficient-memory'
9466 When no error was detected, the value doesn't change. So, to check
9467 the error status of a code conversion by this variable, you must
9468 explicitly set this variable to nil before performing code
9470 Vlast_code_conversion_error
= Qnil
;
9472 DEFVAR_BOOL ("inhibit-eol-conversion", &inhibit_eol_conversion
,
9474 *Non-nil means always inhibit code conversion of end-of-line format.
9475 See info node `Coding Systems' and info node `Text and Binary' concerning
9476 such conversion. */);
9477 inhibit_eol_conversion
= 0;
9479 DEFVAR_BOOL ("inherit-process-coding-system", &inherit_process_coding_system
,
9481 Non-nil means process buffer inherits coding system of process output.
9482 Bind it to t if the process output is to be treated as if it were a file
9483 read from some filesystem. */);
9484 inherit_process_coding_system
= 0;
9486 DEFVAR_LISP ("file-coding-system-alist", &Vfile_coding_system_alist
,
9488 Alist to decide a coding system to use for a file I/O operation.
9489 The format is ((PATTERN . VAL) ...),
9490 where PATTERN is a regular expression matching a file name,
9491 VAL is a coding system, a cons of coding systems, or a function symbol.
9492 If VAL is a coding system, it is used for both decoding and encoding
9494 If VAL is a cons of coding systems, the car part is used for decoding,
9495 and the cdr part is used for encoding.
9496 If VAL is a function symbol, the function must return a coding system
9497 or a cons of coding systems which are used as above. The function gets
9498 the arguments with which `find-operation-coding-systems' was called.
9500 See also the function `find-operation-coding-system'
9501 and the variable `auto-coding-alist'. */);
9502 Vfile_coding_system_alist
= Qnil
;
9504 DEFVAR_LISP ("process-coding-system-alist", &Vprocess_coding_system_alist
,
9506 Alist to decide a coding system to use for a process I/O operation.
9507 The format is ((PATTERN . VAL) ...),
9508 where PATTERN is a regular expression matching a program name,
9509 VAL is a coding system, a cons of coding systems, or a function symbol.
9510 If VAL is a coding system, it is used for both decoding what received
9511 from the program and encoding what sent to the program.
9512 If VAL is a cons of coding systems, the car part is used for decoding,
9513 and the cdr part is used for encoding.
9514 If VAL is a function symbol, the function must return a coding system
9515 or a cons of coding systems which are used as above.
9517 See also the function `find-operation-coding-system'. */);
9518 Vprocess_coding_system_alist
= Qnil
;
9520 DEFVAR_LISP ("network-coding-system-alist", &Vnetwork_coding_system_alist
,
9522 Alist to decide a coding system to use for a network I/O operation.
9523 The format is ((PATTERN . VAL) ...),
9524 where PATTERN is a regular expression matching a network service name
9525 or is a port number to connect to,
9526 VAL is a coding system, a cons of coding systems, or a function symbol.
9527 If VAL is a coding system, it is used for both decoding what received
9528 from the network stream and encoding what sent to the network stream.
9529 If VAL is a cons of coding systems, the car part is used for decoding,
9530 and the cdr part is used for encoding.
9531 If VAL is a function symbol, the function must return a coding system
9532 or a cons of coding systems which are used as above.
9534 See also the function `find-operation-coding-system'. */);
9535 Vnetwork_coding_system_alist
= Qnil
;
9537 DEFVAR_LISP ("locale-coding-system", &Vlocale_coding_system
,
9538 doc
: /* Coding system to use with system messages.
9539 Also used for decoding keyboard input on X Window system. */);
9540 Vlocale_coding_system
= Qnil
;
9542 /* The eol mnemonics are reset in startup.el system-dependently. */
9543 DEFVAR_LISP ("eol-mnemonic-unix", &eol_mnemonic_unix
,
9545 *String displayed in mode line for UNIX-like (LF) end-of-line format. */);
9546 eol_mnemonic_unix
= build_string (":");
9548 DEFVAR_LISP ("eol-mnemonic-dos", &eol_mnemonic_dos
,
9550 *String displayed in mode line for DOS-like (CRLF) end-of-line format. */);
9551 eol_mnemonic_dos
= build_string ("\\");
9553 DEFVAR_LISP ("eol-mnemonic-mac", &eol_mnemonic_mac
,
9555 *String displayed in mode line for MAC-like (CR) end-of-line format. */);
9556 eol_mnemonic_mac
= build_string ("/");
9558 DEFVAR_LISP ("eol-mnemonic-undecided", &eol_mnemonic_undecided
,
9560 *String displayed in mode line when end-of-line format is not yet determined. */);
9561 eol_mnemonic_undecided
= build_string (":");
9563 DEFVAR_LISP ("enable-character-translation", &Venable_character_translation
,
9565 *Non-nil enables character translation while encoding and decoding. */);
9566 Venable_character_translation
= Qt
;
9568 DEFVAR_LISP ("standard-translation-table-for-decode",
9569 &Vstandard_translation_table_for_decode
,
9570 doc
: /* Table for translating characters while decoding. */);
9571 Vstandard_translation_table_for_decode
= Qnil
;
9573 DEFVAR_LISP ("standard-translation-table-for-encode",
9574 &Vstandard_translation_table_for_encode
,
9575 doc
: /* Table for translating characters while encoding. */);
9576 Vstandard_translation_table_for_encode
= Qnil
;
9578 DEFVAR_LISP ("charset-revision-table", &Vcharset_revision_table
,
9579 doc
: /* Alist of charsets vs revision numbers.
9580 While encoding, if a charset (car part of an element) is found,
9581 designate it with the escape sequence identifying revision (cdr part
9582 of the element). */);
9583 Vcharset_revision_table
= Qnil
;
9585 DEFVAR_LISP ("default-process-coding-system",
9586 &Vdefault_process_coding_system
,
9587 doc
: /* Cons of coding systems used for process I/O by default.
9588 The car part is used for decoding a process output,
9589 the cdr part is used for encoding a text to be sent to a process. */);
9590 Vdefault_process_coding_system
= Qnil
;
9592 DEFVAR_LISP ("latin-extra-code-table", &Vlatin_extra_code_table
,
9594 Table of extra Latin codes in the range 128..159 (inclusive).
9595 This is a vector of length 256.
9596 If Nth element is non-nil, the existence of code N in a file
9597 \(or output of subprocess) doesn't prevent it to be detected as
9598 a coding system of ISO 2022 variant which has a flag
9599 `accept-latin-extra-code' t (e.g. iso-latin-1) on reading a file
9600 or reading output of a subprocess.
9601 Only 128th through 159th elements has a meaning. */);
9602 Vlatin_extra_code_table
= Fmake_vector (make_number (256), Qnil
);
9604 DEFVAR_LISP ("select-safe-coding-system-function",
9605 &Vselect_safe_coding_system_function
,
9607 Function to call to select safe coding system for encoding a text.
9609 If set, this function is called to force a user to select a proper
9610 coding system which can encode the text in the case that a default
9611 coding system used in each operation can't encode the text.
9613 The default value is `select-safe-coding-system' (which see). */);
9614 Vselect_safe_coding_system_function
= Qnil
;
9616 DEFVAR_BOOL ("coding-system-require-warning",
9617 &coding_system_require_warning
,
9618 doc
: /* Internal use only.
9619 If non-nil, on writing a file, `select-safe-coding-system-function' is
9620 called even if `coding-system-for-write' is non-nil. The command
9621 `universal-coding-system-argument' binds this variable to t temporarily. */);
9622 coding_system_require_warning
= 0;
9625 DEFVAR_BOOL ("inhibit-iso-escape-detection",
9626 &inhibit_iso_escape_detection
,
9628 If non-nil, Emacs ignores ISO2022's escape sequence on code detection.
9630 By default, on reading a file, Emacs tries to detect how the text is
9631 encoded. This code detection is sensitive to escape sequences. If
9632 the sequence is valid as ISO2022, the code is determined as one of
9633 the ISO2022 encodings, and the file is decoded by the corresponding
9634 coding system (e.g. `iso-2022-7bit').
9636 However, there may be a case that you want to read escape sequences in
9637 a file as is. In such a case, you can set this variable to non-nil.
9638 Then, as the code detection ignores any escape sequences, no file is
9639 detected as encoded in some ISO2022 encoding. The result is that all
9640 escape sequences become visible in a buffer.
9642 The default value is nil, and it is strongly recommended not to change
9643 it. That is because many Emacs Lisp source files that contain
9644 non-ASCII characters are encoded by the coding system `iso-2022-7bit'
9645 in Emacs's distribution, and they won't be decoded correctly on
9646 reading if you suppress escape sequence detection.
9648 The other way to read escape sequences in a file without decoding is
9649 to explicitly specify some coding system that doesn't use ISO2022's
9650 escape sequence (e.g `latin-1') on reading by \\[universal-coding-system-argument]. */);
9651 inhibit_iso_escape_detection
= 0;
9653 DEFVAR_LISP ("translation-table-for-input", &Vtranslation_table_for_input
,
9654 doc
: /* Char table for translating self-inserting characters.
9655 This is applied to the result of input methods, not their input. See also
9656 `keyboard-translate-table'. */);
9657 Vtranslation_table_for_input
= Qnil
;
9660 Lisp_Object args
[coding_arg_max
];
9661 Lisp_Object plist
[16];
9664 for (i
= 0; i
< coding_arg_max
; i
++)
9667 plist
[0] = intern (":name");
9668 plist
[1] = args
[coding_arg_name
] = Qno_conversion
;
9669 plist
[2] = intern (":mnemonic");
9670 plist
[3] = args
[coding_arg_mnemonic
] = make_number ('=');
9671 plist
[4] = intern (":coding-type");
9672 plist
[5] = args
[coding_arg_coding_type
] = Qraw_text
;
9673 plist
[6] = intern (":ascii-compatible-p");
9674 plist
[7] = args
[coding_arg_ascii_compatible_p
] = Qt
;
9675 plist
[8] = intern (":default-char");
9676 plist
[9] = args
[coding_arg_default_char
] = make_number (0);
9677 plist
[10] = intern (":for-unibyte");
9678 plist
[11] = args
[coding_arg_for_unibyte
] = Qt
;
9679 plist
[12] = intern (":docstring");
9680 plist
[13] = build_string ("Do no conversion.\n\
9682 When you visit a file with this coding, the file is read into a\n\
9683 unibyte buffer as is, thus each byte of a file is treated as a\n\
9685 plist
[14] = intern (":eol-type");
9686 plist
[15] = args
[coding_arg_eol_type
] = Qunix
;
9687 args
[coding_arg_plist
] = Flist (16, plist
);
9688 Fdefine_coding_system_internal (coding_arg_max
, args
);
9690 plist
[1] = args
[coding_arg_name
] = Qundecided
;
9691 plist
[3] = args
[coding_arg_mnemonic
] = make_number ('-');
9692 plist
[5] = args
[coding_arg_coding_type
] = Qundecided
;
9693 /* This is already set.
9694 plist[7] = args[coding_arg_ascii_compatible_p] = Qt; */
9695 plist
[8] = intern (":charset-list");
9696 plist
[9] = args
[coding_arg_charset_list
] = Fcons (Qascii
, Qnil
);
9697 plist
[11] = args
[coding_arg_for_unibyte
] = Qnil
;
9698 plist
[13] = build_string ("No conversion on encoding, automatic conversion on decoding.");
9699 plist
[15] = args
[coding_arg_eol_type
] = Qnil
;
9700 args
[coding_arg_plist
] = Flist (16, plist
);
9701 Fdefine_coding_system_internal (coding_arg_max
, args
);
9704 setup_coding_system (Qno_conversion
, &keyboard_coding
);
9705 setup_coding_system (Qundecided
, &terminal_coding
);
9706 setup_coding_system (Qno_conversion
, &safe_terminal_coding
);
9711 for (i
= 0; i
< coding_category_max
; i
++)
9712 Fset (AREF (Vcoding_category_table
, i
), Qno_conversion
);
9717 emacs_strerror (error_number
)
9722 synchronize_system_messages_locale ();
9723 str
= strerror (error_number
);
9725 if (! NILP (Vlocale_coding_system
))
9727 Lisp_Object dec
= code_convert_string_norecord (build_string (str
),
9728 Vlocale_coding_system
,
9730 str
= (char *) SDATA (dec
);
9738 /* arch-tag: 3a3a2b01-5ff6-4071-9afe-f5b808d9229d
9739 (do not change this comment) */