1 /* Coding system handler (conversion, detection, etc).
2 Copyright (C) 2001, 2002, 2003, 2004, 2005,
3 2006, 2007, 2008 Free Software Foundation, Inc.
4 Copyright (C) 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004,
6 National Institute of Advanced Industrial Science and Technology (AIST)
7 Registration Number H14PRO021
9 National Institute of Advanced Industrial Science and Technology (AIST)
10 Registration Number H13PRO009
12 This file is part of GNU Emacs.
14 GNU Emacs is free software; you can redistribute it and/or modify
15 it under the terms of the GNU General Public License as published by
16 the Free Software Foundation; either version 3, or (at your option)
19 GNU Emacs is distributed in the hope that it will be useful,
20 but WITHOUT ANY WARRANTY; without even the implied warranty of
21 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
22 GNU General Public License for more details.
24 You should have received a copy of the GNU General Public License
25 along with GNU Emacs; see the file COPYING. If not, write to
26 the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
27 Boston, MA 02110-1301, USA. */
29 /*** TABLE OF CONTENTS ***
33 2. Emacs' internal format (emacs-utf-8) handlers
36 5. Charset-base coding systems handlers
37 6. emacs-mule (old Emacs' internal format) handlers
39 8. Shift-JIS and BIG5 handlers
41 10. C library functions
42 11. Emacs Lisp library functions
47 /*** 0. General comments ***
52 A coding system is an object for an encoding mechanism that contains
53 information about how to convert byte sequences to character
54 sequences and vice versa. When we say "decode", it means converting
55 a byte sequence of a specific coding system into a character
56 sequence that is represented by Emacs' internal coding system
57 `emacs-utf-8', and when we say "encode", it means converting a
58 character sequence of emacs-utf-8 to a byte sequence of a specific
61 In Emacs Lisp, a coding system is represented by a Lisp symbol. In
62 C level, a coding system is represented by a vector of attributes
63 stored in the hash table Vcharset_hash_table. The conversion from
64 coding system symbol to attributes vector is done by looking up
65 Vcharset_hash_table by the symbol.
67 Coding systems are classified into the following types depending on
68 the encoding mechanism. Here's a brief description of the types.
74 o Charset-base coding system
76 A coding system defined by one or more (coded) character sets.
77 Decoding and encoding are done by a code converter defined for each
80 o Old Emacs internal format (emacs-mule)
82 The coding system adopted by old versions of Emacs (20 and 21).
84 o ISO2022-base coding system
86 The most famous coding system for multiple character sets. X's
87 Compound Text, various EUCs (Extended Unix Code), and coding systems
88 used in the Internet communication such as ISO-2022-JP are all
91 o SJIS (or Shift-JIS or MS-Kanji-Code)
93 A coding system to encode character sets: ASCII, JISX0201, and
94 JISX0208. Widely used for PC's in Japan. Details are described in
99 A coding system to encode character sets: ASCII and Big5. Widely
100 used for Chinese (mainly in Taiwan and Hong Kong). Details are
101 described in section 8. In this file, when we write "big5" (all
102 lowercase), we mean the coding system, and when we write "Big5"
103 (capitalized), we mean the character set.
107 If a user wants to decode/encode text encoded in a coding system
108 not listed above, he can supply a decoder and an encoder for it in
109 CCL (Code Conversion Language) programs. Emacs executes the CCL
110 program while decoding/encoding.
114 A coding system for text containing raw eight-bit data. Emacs
115 treats each byte of source text as a character (except for
116 end-of-line conversion).
120 Like raw text, but don't do end-of-line conversion.
125 How text end-of-line is encoded depends on operating system. For
126 instance, Unix's format is just one byte of LF (line-feed) code,
127 whereas DOS's format is two-byte sequence of `carriage-return' and
128 `line-feed' codes. MacOS's format is usually one byte of
131 Since text character encoding and end-of-line encoding are
132 independent, any coding system described above can take any format
133 of end-of-line (except for no-conversion).
137 Before using a coding system for code conversion (i.e. decoding and
138 encoding), we setup a structure of type `struct coding_system'.
139 This structure keeps various information about a specific code
140 conversion (e.g. the location of source and destination data).
147 /*** GENERAL NOTES on `detect_coding_XXX ()' functions ***
149 These functions check if a byte sequence specified as a source in
150 CODING conforms to the format of XXX, and update the members of
153 Return 1 if the byte sequence conforms to XXX, otherwise return 0.
155 Below is the template of these functions. */
159 detect_coding_XXX (coding
, detect_info
)
160 struct coding_system
*coding
;
161 struct coding_detection_info
*detect_info
;
163 const unsigned char *src
= coding
->source
;
164 const unsigned char *src_end
= coding
->source
+ coding
->src_bytes
;
165 int multibytep
= coding
->src_multibyte
;
166 int consumed_chars
= 0;
172 /* Get one byte from the source. If the souce is exausted, jump
173 to no_more_source:. */
176 if (! __C_conforms_to_XXX___ (c
))
178 if (! __C_strongly_suggests_XXX__ (c
))
179 found
= CATEGORY_MASK_XXX
;
181 /* The byte sequence is invalid for XXX. */
182 detect_info
->rejected
|= CATEGORY_MASK_XXX
;
186 /* The source exausted successfully. */
187 detect_info
->found
|= found
;
192 /*** GENERAL NOTES on `decode_coding_XXX ()' functions ***
194 These functions decode a byte sequence specified as a source by
195 CODING. The resulting multibyte text goes to a place pointed to by
196 CODING->charbuf, the length of which should not exceed
197 CODING->charbuf_size;
199 These functions set the information of original and decoded texts in
200 CODING->consumed, CODING->consumed_char, and CODING->charbuf_used.
201 They also set CODING->result to one of CODING_RESULT_XXX indicating
202 how the decoding is finished.
204 Below is the template of these functions. */
208 decode_coding_XXXX (coding
)
209 struct coding_system
*coding
;
211 const unsigned char *src
= coding
->source
+ coding
->consumed
;
212 const unsigned char *src_end
= coding
->source
+ coding
->src_bytes
;
213 /* SRC_BASE remembers the start position in source in each loop.
214 The loop will be exited when there's not enough source code, or
215 when there's no room in CHARBUF for a decoded character. */
216 const unsigned char *src_base
;
217 /* A buffer to produce decoded characters. */
218 int *charbuf
= coding
->charbuf
+ coding
->charbuf_used
;
219 int *charbuf_end
= coding
->charbuf
+ coding
->charbuf_size
;
220 int multibytep
= coding
->src_multibyte
;
225 if (charbuf
< charbuf_end
)
226 /* No more room to produce a decoded character. */
233 if (src_base
< src_end
234 && coding
->mode
& CODING_MODE_LAST_BLOCK
)
235 /* If the source ends by partial bytes to construct a character,
236 treat them as eight-bit raw data. */
237 while (src_base
< src_end
&& charbuf
< charbuf_end
)
238 *charbuf
++ = *src_base
++;
239 /* Remember how many bytes and characters we consumed. If the
240 source is multibyte, the bytes and chars are not identical. */
241 coding
->consumed
= coding
->consumed_char
= src_base
- coding
->source
;
242 /* Remember how many characters we produced. */
243 coding
->charbuf_used
= charbuf
- coding
->charbuf
;
247 /*** GENERAL NOTES on `encode_coding_XXX ()' functions ***
249 These functions encode SRC_BYTES length text at SOURCE of Emacs'
250 internal multibyte format by CODING. The resulting byte sequence
251 goes to a place pointed to by DESTINATION, the length of which
252 should not exceed DST_BYTES.
254 These functions set the information of original and encoded texts in
255 the members produced, produced_char, consumed, and consumed_char of
256 the structure *CODING. They also set the member result to one of
257 CODING_RESULT_XXX indicating how the encoding finished.
259 DST_BYTES zero means that source area and destination area are
260 overlapped, which means that we can produce a encoded text until it
261 reaches at the head of not-yet-encoded source text.
263 Below is a template of these functions. */
266 encode_coding_XXX (coding
)
267 struct coding_system
*coding
;
269 int multibytep
= coding
->dst_multibyte
;
270 int *charbuf
= coding
->charbuf
;
271 int *charbuf_end
= charbuf
->charbuf
+ coding
->charbuf_used
;
272 unsigned char *dst
= coding
->destination
+ coding
->produced
;
273 unsigned char *dst_end
= coding
->destination
+ coding
->dst_bytes
;
274 unsigned char *adjusted_dst_end
= dst_end
- _MAX_BYTES_PRODUCED_IN_LOOP_
;
275 int produced_chars
= 0;
277 for (; charbuf
< charbuf_end
&& dst
< adjusted_dst_end
; charbuf
++)
280 /* Encode C into DST, and increment DST. */
282 label_no_more_destination
:
283 /* How many chars and bytes we produced. */
284 coding
->produced_char
+= produced_chars
;
285 coding
->produced
= dst
- coding
->destination
;
290 /*** 1. Preamble ***/
297 #include "character.h"
300 #include "composite.h"
304 #include "termhooks.h"
306 Lisp_Object Vcoding_system_hash_table
;
308 Lisp_Object Qcoding_system
, Qcoding_aliases
, Qeol_type
;
309 Lisp_Object Qunix
, Qdos
;
310 extern Lisp_Object Qmac
; /* frame.c */
311 Lisp_Object Qbuffer_file_coding_system
;
312 Lisp_Object Qpost_read_conversion
, Qpre_write_conversion
;
313 Lisp_Object Qdefault_char
;
314 Lisp_Object Qno_conversion
, Qundecided
;
315 Lisp_Object Qcharset
, Qiso_2022
, Qutf_8
, Qutf_16
, Qshift_jis
, Qbig5
;
316 Lisp_Object Qbig
, Qlittle
;
317 Lisp_Object Qcoding_system_history
;
318 Lisp_Object Qvalid_codes
;
319 Lisp_Object QCcategory
, QCmnemonic
, QCdefalut_char
;
320 Lisp_Object QCdecode_translation_table
, QCencode_translation_table
;
321 Lisp_Object QCpost_read_conversion
, QCpre_write_conversion
;
322 Lisp_Object QCascii_compatible_p
;
324 extern Lisp_Object Qinsert_file_contents
, Qwrite_region
;
325 Lisp_Object Qcall_process
, Qcall_process_region
;
326 Lisp_Object Qstart_process
, Qopen_network_stream
;
327 Lisp_Object Qtarget_idx
;
329 Lisp_Object Qinsufficient_source
, Qinconsistent_eol
, Qinvalid_source
;
330 Lisp_Object Qinterrupted
, Qinsufficient_memory
;
332 extern Lisp_Object Qcompletion_ignore_case
;
334 /* If a symbol has this property, evaluate the value to define the
335 symbol as a coding system. */
336 static Lisp_Object Qcoding_system_define_form
;
338 int coding_system_require_warning
;
340 Lisp_Object Vselect_safe_coding_system_function
;
342 /* Mnemonic string for each format of end-of-line. */
343 Lisp_Object eol_mnemonic_unix
, eol_mnemonic_dos
, eol_mnemonic_mac
;
344 /* Mnemonic string to indicate format of end-of-line is not yet
346 Lisp_Object eol_mnemonic_undecided
;
348 /* Format of end-of-line decided by system. This is Qunix on
349 Unix and Mac, Qdos on DOS/Windows.
350 This has an effect only for external encoding (i.e. for output to
351 file and process), not for in-buffer or Lisp string encoding. */
352 static Lisp_Object system_eol_type
;
356 Lisp_Object Vcoding_system_list
, Vcoding_system_alist
;
358 Lisp_Object Qcoding_system_p
, Qcoding_system_error
;
360 /* Coding system emacs-mule and raw-text are for converting only
361 end-of-line format. */
362 Lisp_Object Qemacs_mule
, Qraw_text
;
363 Lisp_Object Qutf_8_emacs
;
365 /* Coding-systems are handed between Emacs Lisp programs and C internal
366 routines by the following three variables. */
367 /* Coding-system for reading files and receiving data from process. */
368 Lisp_Object Vcoding_system_for_read
;
369 /* Coding-system for writing files and sending data to process. */
370 Lisp_Object Vcoding_system_for_write
;
371 /* Coding-system actually used in the latest I/O. */
372 Lisp_Object Vlast_coding_system_used
;
373 /* Set to non-nil when an error is detected while code conversion. */
374 Lisp_Object Vlast_code_conversion_error
;
375 /* A vector of length 256 which contains information about special
376 Latin codes (especially for dealing with Microsoft codes). */
377 Lisp_Object Vlatin_extra_code_table
;
379 /* Flag to inhibit code conversion of end-of-line format. */
380 int inhibit_eol_conversion
;
382 /* Flag to inhibit ISO2022 escape sequence detection. */
383 int inhibit_iso_escape_detection
;
385 /* Flag to make buffer-file-coding-system inherit from process-coding. */
386 int inherit_process_coding_system
;
388 /* Coding system to be used to encode text for terminal display when
389 terminal coding system is nil. */
390 struct coding_system safe_terminal_coding
;
392 Lisp_Object Vfile_coding_system_alist
;
393 Lisp_Object Vprocess_coding_system_alist
;
394 Lisp_Object Vnetwork_coding_system_alist
;
396 Lisp_Object Vlocale_coding_system
;
400 /* Flag to tell if we look up translation table on character code
402 Lisp_Object Venable_character_translation
;
403 /* Standard translation table to look up on decoding (reading). */
404 Lisp_Object Vstandard_translation_table_for_decode
;
405 /* Standard translation table to look up on encoding (writing). */
406 Lisp_Object Vstandard_translation_table_for_encode
;
408 Lisp_Object Qtranslation_table
;
409 Lisp_Object Qtranslation_table_id
;
410 Lisp_Object Qtranslation_table_for_decode
;
411 Lisp_Object Qtranslation_table_for_encode
;
413 /* Alist of charsets vs revision number. */
414 static Lisp_Object Vcharset_revision_table
;
416 /* Default coding systems used for process I/O. */
417 Lisp_Object Vdefault_process_coding_system
;
419 /* Char table for translating Quail and self-inserting input. */
420 Lisp_Object Vtranslation_table_for_input
;
422 /* Two special coding systems. */
423 Lisp_Object Vsjis_coding_system
;
424 Lisp_Object Vbig5_coding_system
;
426 /* ISO2022 section */
428 #define CODING_ISO_INITIAL(coding, reg) \
429 (XINT (AREF (AREF (CODING_ID_ATTRS ((coding)->id), \
430 coding_attr_iso_initial), \
434 #define CODING_ISO_REQUEST(coding, charset_id) \
435 ((charset_id <= (coding)->max_charset_id \
436 ? (coding)->safe_charsets[charset_id] \
440 #define CODING_ISO_FLAGS(coding) \
441 ((coding)->spec.iso_2022.flags)
442 #define CODING_ISO_DESIGNATION(coding, reg) \
443 ((coding)->spec.iso_2022.current_designation[reg])
444 #define CODING_ISO_INVOCATION(coding, plane) \
445 ((coding)->spec.iso_2022.current_invocation[plane])
446 #define CODING_ISO_SINGLE_SHIFTING(coding) \
447 ((coding)->spec.iso_2022.single_shifting)
448 #define CODING_ISO_BOL(coding) \
449 ((coding)->spec.iso_2022.bol)
450 #define CODING_ISO_INVOKED_CHARSET(coding, plane) \
451 CODING_ISO_DESIGNATION ((coding), CODING_ISO_INVOCATION ((coding), (plane)))
453 /* Control characters of ISO2022. */
454 /* code */ /* function */
455 #define ISO_CODE_LF 0x0A /* line-feed */
456 #define ISO_CODE_CR 0x0D /* carriage-return */
457 #define ISO_CODE_SO 0x0E /* shift-out */
458 #define ISO_CODE_SI 0x0F /* shift-in */
459 #define ISO_CODE_SS2_7 0x19 /* single-shift-2 for 7-bit code */
460 #define ISO_CODE_ESC 0x1B /* escape */
461 #define ISO_CODE_SS2 0x8E /* single-shift-2 */
462 #define ISO_CODE_SS3 0x8F /* single-shift-3 */
463 #define ISO_CODE_CSI 0x9B /* control-sequence-introducer */
465 /* All code (1-byte) of ISO2022 is classified into one of the
467 enum iso_code_class_type
469 ISO_control_0
, /* Control codes in the range
470 0x00..0x1F and 0x7F, except for the
471 following 5 codes. */
472 ISO_shift_out
, /* ISO_CODE_SO (0x0E) */
473 ISO_shift_in
, /* ISO_CODE_SI (0x0F) */
474 ISO_single_shift_2_7
, /* ISO_CODE_SS2_7 (0x19) */
475 ISO_escape
, /* ISO_CODE_SO (0x1B) */
476 ISO_control_1
, /* Control codes in the range
477 0x80..0x9F, except for the
478 following 3 codes. */
479 ISO_single_shift_2
, /* ISO_CODE_SS2 (0x8E) */
480 ISO_single_shift_3
, /* ISO_CODE_SS3 (0x8F) */
481 ISO_control_sequence_introducer
, /* ISO_CODE_CSI (0x9B) */
482 ISO_0x20_or_0x7F
, /* Codes of the values 0x20 or 0x7F. */
483 ISO_graphic_plane_0
, /* Graphic codes in the range 0x21..0x7E. */
484 ISO_0xA0_or_0xFF
, /* Codes of the values 0xA0 or 0xFF. */
485 ISO_graphic_plane_1
/* Graphic codes in the range 0xA1..0xFE. */
488 /** The macros CODING_ISO_FLAG_XXX defines a flag bit of the
489 `iso-flags' attribute of an iso2022 coding system. */
491 /* If set, produce long-form designation sequence (e.g. ESC $ ( A)
492 instead of the correct short-form sequence (e.g. ESC $ A). */
493 #define CODING_ISO_FLAG_LONG_FORM 0x0001
495 /* If set, reset graphic planes and registers at end-of-line to the
497 #define CODING_ISO_FLAG_RESET_AT_EOL 0x0002
499 /* If set, reset graphic planes and registers before any control
500 characters to the initial state. */
501 #define CODING_ISO_FLAG_RESET_AT_CNTL 0x0004
503 /* If set, encode by 7-bit environment. */
504 #define CODING_ISO_FLAG_SEVEN_BITS 0x0008
506 /* If set, use locking-shift function. */
507 #define CODING_ISO_FLAG_LOCKING_SHIFT 0x0010
509 /* If set, use single-shift function. Overwrite
510 CODING_ISO_FLAG_LOCKING_SHIFT. */
511 #define CODING_ISO_FLAG_SINGLE_SHIFT 0x0020
513 /* If set, use designation escape sequence. */
514 #define CODING_ISO_FLAG_DESIGNATION 0x0040
516 /* If set, produce revision number sequence. */
517 #define CODING_ISO_FLAG_REVISION 0x0080
519 /* If set, produce ISO6429's direction specifying sequence. */
520 #define CODING_ISO_FLAG_DIRECTION 0x0100
522 /* If set, assume designation states are reset at beginning of line on
524 #define CODING_ISO_FLAG_INIT_AT_BOL 0x0200
526 /* If set, designation sequence should be placed at beginning of line
528 #define CODING_ISO_FLAG_DESIGNATE_AT_BOL 0x0400
530 /* If set, do not encode unsafe charactes on output. */
531 #define CODING_ISO_FLAG_SAFE 0x0800
533 /* If set, extra latin codes (128..159) are accepted as a valid code
535 #define CODING_ISO_FLAG_LATIN_EXTRA 0x1000
537 #define CODING_ISO_FLAG_COMPOSITION 0x2000
539 #define CODING_ISO_FLAG_EUC_TW_SHIFT 0x4000
541 #define CODING_ISO_FLAG_USE_ROMAN 0x8000
543 #define CODING_ISO_FLAG_USE_OLDJIS 0x10000
545 #define CODING_ISO_FLAG_FULL_SUPPORT 0x100000
547 /* A character to be produced on output if encoding of the original
548 character is prohibited by CODING_ISO_FLAG_SAFE. */
549 #define CODING_INHIBIT_CHARACTER_SUBSTITUTION '?'
553 #define CODING_UTF_16_BOM(coding) \
554 ((coding)->spec.utf_16.bom)
556 #define CODING_UTF_16_ENDIAN(coding) \
557 ((coding)->spec.utf_16.endian)
559 #define CODING_UTF_16_SURROGATE(coding) \
560 ((coding)->spec.utf_16.surrogate)
564 #define CODING_CCL_DECODER(coding) \
565 AREF (CODING_ID_ATTRS ((coding)->id), coding_attr_ccl_decoder)
566 #define CODING_CCL_ENCODER(coding) \
567 AREF (CODING_ID_ATTRS ((coding)->id), coding_attr_ccl_encoder)
568 #define CODING_CCL_VALIDS(coding) \
569 (SDATA (AREF (CODING_ID_ATTRS ((coding)->id), coding_attr_ccl_valids)))
571 /* Index for each coding category in `coding_categories' */
575 coding_category_iso_7
,
576 coding_category_iso_7_tight
,
577 coding_category_iso_8_1
,
578 coding_category_iso_8_2
,
579 coding_category_iso_7_else
,
580 coding_category_iso_8_else
,
581 coding_category_utf_8
,
582 coding_category_utf_16_auto
,
583 coding_category_utf_16_be
,
584 coding_category_utf_16_le
,
585 coding_category_utf_16_be_nosig
,
586 coding_category_utf_16_le_nosig
,
587 coding_category_charset
,
588 coding_category_sjis
,
589 coding_category_big5
,
591 coding_category_emacs_mule
,
592 /* All above are targets of code detection. */
593 coding_category_raw_text
,
594 coding_category_undecided
,
598 /* Definitions of flag bits used in detect_coding_XXXX. */
599 #define CATEGORY_MASK_ISO_7 (1 << coding_category_iso_7)
600 #define CATEGORY_MASK_ISO_7_TIGHT (1 << coding_category_iso_7_tight)
601 #define CATEGORY_MASK_ISO_8_1 (1 << coding_category_iso_8_1)
602 #define CATEGORY_MASK_ISO_8_2 (1 << coding_category_iso_8_2)
603 #define CATEGORY_MASK_ISO_7_ELSE (1 << coding_category_iso_7_else)
604 #define CATEGORY_MASK_ISO_8_ELSE (1 << coding_category_iso_8_else)
605 #define CATEGORY_MASK_UTF_8 (1 << coding_category_utf_8)
606 #define CATEGORY_MASK_UTF_16_AUTO (1 << coding_category_utf_16_auto)
607 #define CATEGORY_MASK_UTF_16_BE (1 << coding_category_utf_16_be)
608 #define CATEGORY_MASK_UTF_16_LE (1 << coding_category_utf_16_le)
609 #define CATEGORY_MASK_UTF_16_BE_NOSIG (1 << coding_category_utf_16_be_nosig)
610 #define CATEGORY_MASK_UTF_16_LE_NOSIG (1 << coding_category_utf_16_le_nosig)
611 #define CATEGORY_MASK_CHARSET (1 << coding_category_charset)
612 #define CATEGORY_MASK_SJIS (1 << coding_category_sjis)
613 #define CATEGORY_MASK_BIG5 (1 << coding_category_big5)
614 #define CATEGORY_MASK_CCL (1 << coding_category_ccl)
615 #define CATEGORY_MASK_EMACS_MULE (1 << coding_category_emacs_mule)
616 #define CATEGORY_MASK_RAW_TEXT (1 << coding_category_raw_text)
618 /* This value is returned if detect_coding_mask () find nothing other
619 than ASCII characters. */
620 #define CATEGORY_MASK_ANY \
621 (CATEGORY_MASK_ISO_7 \
622 | CATEGORY_MASK_ISO_7_TIGHT \
623 | CATEGORY_MASK_ISO_8_1 \
624 | CATEGORY_MASK_ISO_8_2 \
625 | CATEGORY_MASK_ISO_7_ELSE \
626 | CATEGORY_MASK_ISO_8_ELSE \
627 | CATEGORY_MASK_UTF_8 \
628 | CATEGORY_MASK_UTF_16_BE \
629 | CATEGORY_MASK_UTF_16_LE \
630 | CATEGORY_MASK_UTF_16_BE_NOSIG \
631 | CATEGORY_MASK_UTF_16_LE_NOSIG \
632 | CATEGORY_MASK_CHARSET \
633 | CATEGORY_MASK_SJIS \
634 | CATEGORY_MASK_BIG5 \
635 | CATEGORY_MASK_CCL \
636 | CATEGORY_MASK_EMACS_MULE)
639 #define CATEGORY_MASK_ISO_7BIT \
640 (CATEGORY_MASK_ISO_7 | CATEGORY_MASK_ISO_7_TIGHT)
642 #define CATEGORY_MASK_ISO_8BIT \
643 (CATEGORY_MASK_ISO_8_1 | CATEGORY_MASK_ISO_8_2)
645 #define CATEGORY_MASK_ISO_ELSE \
646 (CATEGORY_MASK_ISO_7_ELSE | CATEGORY_MASK_ISO_8_ELSE)
648 #define CATEGORY_MASK_ISO_ESCAPE \
649 (CATEGORY_MASK_ISO_7 \
650 | CATEGORY_MASK_ISO_7_TIGHT \
651 | CATEGORY_MASK_ISO_7_ELSE \
652 | CATEGORY_MASK_ISO_8_ELSE)
654 #define CATEGORY_MASK_ISO \
655 ( CATEGORY_MASK_ISO_7BIT \
656 | CATEGORY_MASK_ISO_8BIT \
657 | CATEGORY_MASK_ISO_ELSE)
659 #define CATEGORY_MASK_UTF_16 \
660 (CATEGORY_MASK_UTF_16_BE \
661 | CATEGORY_MASK_UTF_16_LE \
662 | CATEGORY_MASK_UTF_16_BE_NOSIG \
663 | CATEGORY_MASK_UTF_16_LE_NOSIG)
666 /* List of symbols `coding-category-xxx' ordered by priority. This
667 variable is exposed to Emacs Lisp. */
668 static Lisp_Object Vcoding_category_list
;
670 /* Table of coding categories (Lisp symbols). This variable is for
672 static Lisp_Object Vcoding_category_table
;
674 /* Table of coding-categories ordered by priority. */
675 static enum coding_category coding_priorities
[coding_category_max
];
677 /* Nth element is a coding context for the coding system bound to the
678 Nth coding category. */
679 static struct coding_system coding_categories
[coding_category_max
];
681 /*** Commonly used macros and functions ***/
684 #define min(a, b) ((a) < (b) ? (a) : (b))
687 #define max(a, b) ((a) > (b) ? (a) : (b))
690 #define CODING_GET_INFO(coding, attrs, charset_list) \
692 (attrs) = CODING_ID_ATTRS ((coding)->id); \
693 (charset_list) = CODING_ATTR_CHARSET_LIST (attrs); \
697 /* Safely get one byte from the source text pointed by SRC which ends
698 at SRC_END, and set C to that byte. If there are not enough bytes
699 in the source, it jumps to `no_more_source'. If multibytep is
700 nonzero, and a multibyte character is found at SRC, set C to the
701 negative value of the character code. The caller should declare
702 and set these variables appropriately in advance:
703 src, src_end, multibytep */
705 #define ONE_MORE_BYTE(c) \
707 if (src == src_end) \
709 if (src_base < src) \
710 record_conversion_result \
711 (coding, CODING_RESULT_INSUFFICIENT_SRC); \
712 goto no_more_source; \
715 if (multibytep && (c & 0x80)) \
717 if ((c & 0xFE) == 0xC0) \
718 c = ((c & 1) << 6) | *src++; \
722 c = - string_char (src, &src, NULL); \
723 record_conversion_result \
724 (coding, CODING_RESULT_INVALID_SRC); \
731 #define ONE_MORE_BYTE_NO_CHECK(c) \
734 if (multibytep && (c & 0x80)) \
736 if ((c & 0xFE) == 0xC0) \
737 c = ((c & 1) << 6) | *src++; \
741 c = - string_char (src, &src, NULL); \
742 record_conversion_result \
743 (coding, CODING_RESULT_INVALID_SRC); \
750 /* Store a byte C in the place pointed by DST and increment DST to the
751 next free point, and increment PRODUCED_CHARS. The caller should
752 assure that C is 0..127, and declare and set the variable `dst'
753 appropriately in advance.
757 #define EMIT_ONE_ASCII_BYTE(c) \
764 /* Like EMIT_ONE_ASCII_BYTE byt store two bytes; C1 and C2. */
766 #define EMIT_TWO_ASCII_BYTES(c1, c2) \
768 produced_chars += 2; \
769 *dst++ = (c1), *dst++ = (c2); \
773 /* Store a byte C in the place pointed by DST and increment DST to the
774 next free point, and increment PRODUCED_CHARS. If MULTIBYTEP is
775 nonzero, store in an appropriate multibyte from. The caller should
776 declare and set the variables `dst' and `multibytep' appropriately
779 #define EMIT_ONE_BYTE(c) \
786 ch = BYTE8_TO_CHAR (ch); \
787 CHAR_STRING_ADVANCE (ch, dst); \
794 /* Like EMIT_ONE_BYTE, but emit two bytes; C1 and C2. */
796 #define EMIT_TWO_BYTES(c1, c2) \
798 produced_chars += 2; \
805 ch = BYTE8_TO_CHAR (ch); \
806 CHAR_STRING_ADVANCE (ch, dst); \
809 ch = BYTE8_TO_CHAR (ch); \
810 CHAR_STRING_ADVANCE (ch, dst); \
820 #define EMIT_THREE_BYTES(c1, c2, c3) \
822 EMIT_ONE_BYTE (c1); \
823 EMIT_TWO_BYTES (c2, c3); \
827 #define EMIT_FOUR_BYTES(c1, c2, c3, c4) \
829 EMIT_TWO_BYTES (c1, c2); \
830 EMIT_TWO_BYTES (c3, c4); \
834 /* Prototypes for static functions. */
835 static void record_conversion_result
P_ ((struct coding_system
*coding
,
836 enum coding_result_code result
));
837 static int detect_coding_utf_8
P_ ((struct coding_system
*,
838 struct coding_detection_info
*info
));
839 static void decode_coding_utf_8
P_ ((struct coding_system
*));
840 static int encode_coding_utf_8
P_ ((struct coding_system
*));
842 static int detect_coding_utf_16
P_ ((struct coding_system
*,
843 struct coding_detection_info
*info
));
844 static void decode_coding_utf_16
P_ ((struct coding_system
*));
845 static int encode_coding_utf_16
P_ ((struct coding_system
*));
847 static int detect_coding_iso_2022
P_ ((struct coding_system
*,
848 struct coding_detection_info
*info
));
849 static void decode_coding_iso_2022
P_ ((struct coding_system
*));
850 static int encode_coding_iso_2022
P_ ((struct coding_system
*));
852 static int detect_coding_emacs_mule
P_ ((struct coding_system
*,
853 struct coding_detection_info
*info
));
854 static void decode_coding_emacs_mule
P_ ((struct coding_system
*));
855 static int encode_coding_emacs_mule
P_ ((struct coding_system
*));
857 static int detect_coding_sjis
P_ ((struct coding_system
*,
858 struct coding_detection_info
*info
));
859 static void decode_coding_sjis
P_ ((struct coding_system
*));
860 static int encode_coding_sjis
P_ ((struct coding_system
*));
862 static int detect_coding_big5
P_ ((struct coding_system
*,
863 struct coding_detection_info
*info
));
864 static void decode_coding_big5
P_ ((struct coding_system
*));
865 static int encode_coding_big5
P_ ((struct coding_system
*));
867 static int detect_coding_ccl
P_ ((struct coding_system
*,
868 struct coding_detection_info
*info
));
869 static void decode_coding_ccl
P_ ((struct coding_system
*));
870 static int encode_coding_ccl
P_ ((struct coding_system
*));
872 static void decode_coding_raw_text
P_ ((struct coding_system
*));
873 static int encode_coding_raw_text
P_ ((struct coding_system
*));
875 static void coding_set_source
P_ ((struct coding_system
*));
876 static void coding_set_destination
P_ ((struct coding_system
*));
877 static void coding_alloc_by_realloc
P_ ((struct coding_system
*, EMACS_INT
));
878 static void coding_alloc_by_making_gap
P_ ((struct coding_system
*,
879 EMACS_INT
, EMACS_INT
));
880 static unsigned char *alloc_destination
P_ ((struct coding_system
*,
881 EMACS_INT
, unsigned char *));
882 static void setup_iso_safe_charsets
P_ ((Lisp_Object
));
883 static unsigned char *encode_designation_at_bol
P_ ((struct coding_system
*,
886 static int detect_eol
P_ ((const unsigned char *,
887 EMACS_INT
, enum coding_category
));
888 static Lisp_Object adjust_coding_eol_type
P_ ((struct coding_system
*, int));
889 static void decode_eol
P_ ((struct coding_system
*));
890 static Lisp_Object get_translation_table
P_ ((Lisp_Object
, int, int *));
891 static Lisp_Object get_translation
P_ ((Lisp_Object
, int *, int *,
893 static int produce_chars
P_ ((struct coding_system
*, Lisp_Object
, int));
894 static INLINE
void produce_composition
P_ ((struct coding_system
*, int *,
896 static INLINE
void produce_charset
P_ ((struct coding_system
*, int *,
898 static void produce_annotation
P_ ((struct coding_system
*, EMACS_INT
));
899 static int decode_coding
P_ ((struct coding_system
*));
900 static INLINE
int *handle_composition_annotation
P_ ((EMACS_INT
, EMACS_INT
,
901 struct coding_system
*,
902 int *, EMACS_INT
*));
903 static INLINE
int *handle_charset_annotation
P_ ((EMACS_INT
, EMACS_INT
,
904 struct coding_system
*,
905 int *, EMACS_INT
*));
906 static void consume_chars
P_ ((struct coding_system
*, Lisp_Object
, int));
907 static int encode_coding
P_ ((struct coding_system
*));
908 static Lisp_Object make_conversion_work_buffer
P_ ((int));
909 static Lisp_Object code_conversion_restore
P_ ((Lisp_Object
));
910 static INLINE
int char_encodable_p
P_ ((int, Lisp_Object
));
911 static Lisp_Object make_subsidiaries
P_ ((Lisp_Object
));
914 record_conversion_result (struct coding_system
*coding
,
915 enum coding_result_code result
)
917 coding
->result
= result
;
920 case CODING_RESULT_INSUFFICIENT_SRC
:
921 Vlast_code_conversion_error
= Qinsufficient_source
;
923 case CODING_RESULT_INCONSISTENT_EOL
:
924 Vlast_code_conversion_error
= Qinconsistent_eol
;
926 case CODING_RESULT_INVALID_SRC
:
927 Vlast_code_conversion_error
= Qinvalid_source
;
929 case CODING_RESULT_INTERRUPT
:
930 Vlast_code_conversion_error
= Qinterrupted
;
932 case CODING_RESULT_INSUFFICIENT_MEM
:
933 Vlast_code_conversion_error
= Qinsufficient_memory
;
936 Vlast_code_conversion_error
= intern ("Unknown error");
940 #define CODING_DECODE_CHAR(coding, src, src_base, src_end, charset, code, c) \
942 charset_map_loaded = 0; \
943 c = DECODE_CHAR (charset, code); \
944 if (charset_map_loaded) \
946 const unsigned char *orig = coding->source; \
949 coding_set_source (coding); \
950 offset = coding->source - orig; \
952 src_base += offset; \
958 #define ASSURE_DESTINATION(bytes) \
960 if (dst + (bytes) >= dst_end) \
962 int more_bytes = charbuf_end - charbuf + (bytes); \
964 dst = alloc_destination (coding, more_bytes, dst); \
965 dst_end = coding->destination + coding->dst_bytes; \
972 coding_set_source (coding
)
973 struct coding_system
*coding
;
975 if (BUFFERP (coding
->src_object
))
977 struct buffer
*buf
= XBUFFER (coding
->src_object
);
979 if (coding
->src_pos
< 0)
980 coding
->source
= BUF_GAP_END_ADDR (buf
) + coding
->src_pos_byte
;
982 coding
->source
= BUF_BYTE_ADDRESS (buf
, coding
->src_pos_byte
);
984 else if (STRINGP (coding
->src_object
))
986 coding
->source
= SDATA (coding
->src_object
) + coding
->src_pos_byte
;
989 /* Otherwise, the source is C string and is never relocated
990 automatically. Thus we don't have to update anything. */
995 coding_set_destination (coding
)
996 struct coding_system
*coding
;
998 if (BUFFERP (coding
->dst_object
))
1000 if (coding
->src_pos
< 0)
1002 coding
->destination
= BEG_ADDR
+ coding
->dst_pos_byte
- 1;
1003 coding
->dst_bytes
= (GAP_END_ADDR
1004 - (coding
->src_bytes
- coding
->consumed
)
1005 - coding
->destination
);
1009 /* We are sure that coding->dst_pos_byte is before the gap
1011 coding
->destination
= (BUF_BEG_ADDR (XBUFFER (coding
->dst_object
))
1012 + coding
->dst_pos_byte
- 1);
1013 coding
->dst_bytes
= (BUF_GAP_END_ADDR (XBUFFER (coding
->dst_object
))
1014 - coding
->destination
);
1018 /* Otherwise, the destination is C string and is never relocated
1019 automatically. Thus we don't have to update anything. */
1025 coding_alloc_by_realloc (coding
, bytes
)
1026 struct coding_system
*coding
;
1029 coding
->destination
= (unsigned char *) xrealloc (coding
->destination
,
1030 coding
->dst_bytes
+ bytes
);
1031 coding
->dst_bytes
+= bytes
;
1035 coding_alloc_by_making_gap (coding
, offset
, bytes
)
1036 struct coding_system
*coding
;
1037 EMACS_INT offset
, bytes
;
1039 if (BUFFERP (coding
->dst_object
)
1040 && EQ (coding
->src_object
, coding
->dst_object
))
1042 EMACS_INT add
= offset
+ (coding
->src_bytes
- coding
->consumed
);
1044 GPT
+= offset
, GPT_BYTE
+= offset
;
1045 GAP_SIZE
-= add
; ZV
+= add
; Z
+= add
; ZV_BYTE
+= add
; Z_BYTE
+= add
;
1047 GAP_SIZE
+= add
; ZV
-= add
; Z
-= add
; ZV_BYTE
-= add
; Z_BYTE
-= add
;
1048 GPT
-= offset
, GPT_BYTE
-= offset
;
1052 Lisp_Object this_buffer
;
1054 this_buffer
= Fcurrent_buffer ();
1055 set_buffer_internal (XBUFFER (coding
->dst_object
));
1057 set_buffer_internal (XBUFFER (this_buffer
));
1062 static unsigned char *
1063 alloc_destination (coding
, nbytes
, dst
)
1064 struct coding_system
*coding
;
1068 EMACS_INT offset
= dst
- coding
->destination
;
1070 if (BUFFERP (coding
->dst_object
))
1071 coding_alloc_by_making_gap (coding
, offset
, nbytes
);
1073 coding_alloc_by_realloc (coding
, nbytes
);
1074 record_conversion_result (coding
, CODING_RESULT_SUCCESS
);
1075 coding_set_destination (coding
);
1076 dst
= coding
->destination
+ offset
;
1080 /** Macros for annotations. */
1082 /* Maximum length of annotation data (sum of annotations for
1083 composition and charset). */
1084 #define MAX_ANNOTATION_LENGTH (4 + (MAX_COMPOSITION_COMPONENTS * 2) - 1 + 4)
1086 /* An annotation data is stored in the array coding->charbuf in this
1088 [ -LENGTH ANNOTATION_MASK NCHARS ... ]
1089 LENGTH is the number of elements in the annotation.
1090 ANNOTATION_MASK is one of CODING_ANNOTATE_XXX_MASK.
1091 NCHARS is the number of characters in the text annotated.
1093 The format of the following elements depend on ANNOTATION_MASK.
1095 In the case of CODING_ANNOTATE_COMPOSITION_MASK, these elements
1097 ... METHOD [ COMPOSITION-COMPONENTS ... ]
1098 METHOD is one of enum composition_method.
1099 Optionnal COMPOSITION-COMPONENTS are characters and composition
1102 In the case of CODING_ANNOTATE_CHARSET_MASK, one element CHARSET-ID
1105 #define ADD_ANNOTATION_DATA(buf, len, mask, nchars) \
1107 *(buf)++ = -(len); \
1108 *(buf)++ = (mask); \
1109 *(buf)++ = (nchars); \
1110 coding->annotated = 1; \
1113 #define ADD_COMPOSITION_DATA(buf, nchars, method) \
1115 ADD_ANNOTATION_DATA (buf, 4, CODING_ANNOTATE_COMPOSITION_MASK, nchars); \
1120 #define ADD_CHARSET_DATA(buf, nchars, id) \
1122 ADD_ANNOTATION_DATA (buf, 4, CODING_ANNOTATE_CHARSET_MASK, nchars); \
1127 /*** 2. Emacs' internal format (emacs-utf-8) ***/
1134 /* See the above "GENERAL NOTES on `detect_coding_XXX ()' functions".
1135 Check if a text is encoded in UTF-8. If it is, return 1, else
1138 #define UTF_8_1_OCTET_P(c) ((c) < 0x80)
1139 #define UTF_8_EXTRA_OCTET_P(c) (((c) & 0xC0) == 0x80)
1140 #define UTF_8_2_OCTET_LEADING_P(c) (((c) & 0xE0) == 0xC0)
1141 #define UTF_8_3_OCTET_LEADING_P(c) (((c) & 0xF0) == 0xE0)
1142 #define UTF_8_4_OCTET_LEADING_P(c) (((c) & 0xF8) == 0xF0)
1143 #define UTF_8_5_OCTET_LEADING_P(c) (((c) & 0xFC) == 0xF8)
1146 detect_coding_utf_8 (coding
, detect_info
)
1147 struct coding_system
*coding
;
1148 struct coding_detection_info
*detect_info
;
1150 const unsigned char *src
= coding
->source
, *src_base
;
1151 const unsigned char *src_end
= coding
->source
+ coding
->src_bytes
;
1152 int multibytep
= coding
->src_multibyte
;
1153 int consumed_chars
= 0;
1156 detect_info
->checked
|= CATEGORY_MASK_UTF_8
;
1157 /* A coding system of this category is always ASCII compatible. */
1158 src
+= coding
->head_ascii
;
1162 int c
, c1
, c2
, c3
, c4
;
1166 if (c
< 0 || UTF_8_1_OCTET_P (c
))
1169 if (c1
< 0 || ! UTF_8_EXTRA_OCTET_P (c1
))
1171 if (UTF_8_2_OCTET_LEADING_P (c
))
1173 found
= CATEGORY_MASK_UTF_8
;
1177 if (c2
< 0 || ! UTF_8_EXTRA_OCTET_P (c2
))
1179 if (UTF_8_3_OCTET_LEADING_P (c
))
1181 found
= CATEGORY_MASK_UTF_8
;
1185 if (c3
< 0 || ! UTF_8_EXTRA_OCTET_P (c3
))
1187 if (UTF_8_4_OCTET_LEADING_P (c
))
1189 found
= CATEGORY_MASK_UTF_8
;
1193 if (c4
< 0 || ! UTF_8_EXTRA_OCTET_P (c4
))
1195 if (UTF_8_5_OCTET_LEADING_P (c
))
1197 found
= CATEGORY_MASK_UTF_8
;
1202 detect_info
->rejected
|= CATEGORY_MASK_UTF_8
;
1206 if (src_base
< src
&& coding
->mode
& CODING_MODE_LAST_BLOCK
)
1208 detect_info
->rejected
|= CATEGORY_MASK_UTF_8
;
1211 detect_info
->found
|= found
;
1217 decode_coding_utf_8 (coding
)
1218 struct coding_system
*coding
;
1220 const unsigned char *src
= coding
->source
+ coding
->consumed
;
1221 const unsigned char *src_end
= coding
->source
+ coding
->src_bytes
;
1222 const unsigned char *src_base
;
1223 int *charbuf
= coding
->charbuf
+ coding
->charbuf_used
;
1224 int *charbuf_end
= coding
->charbuf
+ coding
->charbuf_size
;
1225 int consumed_chars
= 0, consumed_chars_base
;
1226 int multibytep
= coding
->src_multibyte
;
1227 Lisp_Object attr
, charset_list
;
1229 CODING_GET_INFO (coding
, attr
, charset_list
);
1233 int c
, c1
, c2
, c3
, c4
, c5
;
1236 consumed_chars_base
= consumed_chars
;
1238 if (charbuf
>= charbuf_end
)
1246 else if (UTF_8_1_OCTET_P(c1
))
1253 if (c2
< 0 || ! UTF_8_EXTRA_OCTET_P (c2
))
1255 if (UTF_8_2_OCTET_LEADING_P (c1
))
1257 c
= ((c1
& 0x1F) << 6) | (c2
& 0x3F);
1258 /* Reject overlong sequences here and below. Encoders
1259 producing them are incorrect, they can be misleading,
1260 and they mess up read/write invariance. */
1267 if (c3
< 0 || ! UTF_8_EXTRA_OCTET_P (c3
))
1269 if (UTF_8_3_OCTET_LEADING_P (c1
))
1271 c
= (((c1
& 0xF) << 12)
1272 | ((c2
& 0x3F) << 6) | (c3
& 0x3F));
1274 || (c
>= 0xd800 && c
< 0xe000)) /* surrogates (invalid) */
1280 if (c4
< 0 || ! UTF_8_EXTRA_OCTET_P (c4
))
1282 if (UTF_8_4_OCTET_LEADING_P (c1
))
1284 c
= (((c1
& 0x7) << 18) | ((c2
& 0x3F) << 12)
1285 | ((c3
& 0x3F) << 6) | (c4
& 0x3F));
1292 if (c5
< 0 || ! UTF_8_EXTRA_OCTET_P (c5
))
1294 if (UTF_8_5_OCTET_LEADING_P (c1
))
1296 c
= (((c1
& 0x3) << 24) | ((c2
& 0x3F) << 18)
1297 | ((c3
& 0x3F) << 12) | ((c4
& 0x3F) << 6)
1299 if ((c
> MAX_CHAR
) || (c
< 0x200000))
1314 consumed_chars
= consumed_chars_base
;
1316 *charbuf
++ = ASCII_BYTE_P (c
) ? c
: BYTE8_TO_CHAR (c
);
1321 coding
->consumed_char
+= consumed_chars_base
;
1322 coding
->consumed
= src_base
- coding
->source
;
1323 coding
->charbuf_used
= charbuf
- coding
->charbuf
;
1328 encode_coding_utf_8 (coding
)
1329 struct coding_system
*coding
;
1331 int multibytep
= coding
->dst_multibyte
;
1332 int *charbuf
= coding
->charbuf
;
1333 int *charbuf_end
= charbuf
+ coding
->charbuf_used
;
1334 unsigned char *dst
= coding
->destination
+ coding
->produced
;
1335 unsigned char *dst_end
= coding
->destination
+ coding
->dst_bytes
;
1336 int produced_chars
= 0;
1341 int safe_room
= MAX_MULTIBYTE_LENGTH
* 2;
1343 while (charbuf
< charbuf_end
)
1345 unsigned char str
[MAX_MULTIBYTE_LENGTH
], *p
, *pend
= str
;
1347 ASSURE_DESTINATION (safe_room
);
1349 if (CHAR_BYTE8_P (c
))
1351 c
= CHAR_TO_BYTE8 (c
);
1356 CHAR_STRING_ADVANCE (c
, pend
);
1357 for (p
= str
; p
< pend
; p
++)
1364 int safe_room
= MAX_MULTIBYTE_LENGTH
;
1366 while (charbuf
< charbuf_end
)
1368 ASSURE_DESTINATION (safe_room
);
1370 if (CHAR_BYTE8_P (c
))
1371 *dst
++ = CHAR_TO_BYTE8 (c
);
1373 dst
+= CHAR_STRING (c
, dst
);
1377 record_conversion_result (coding
, CODING_RESULT_SUCCESS
);
1378 coding
->produced_char
+= produced_chars
;
1379 coding
->produced
= dst
- coding
->destination
;
1384 /* See the above "GENERAL NOTES on `detect_coding_XXX ()' functions".
1385 Check if a text is encoded in one of UTF-16 based coding systems.
1386 If it is, return 1, else return 0. */
1388 #define UTF_16_HIGH_SURROGATE_P(val) \
1389 (((val) & 0xFC00) == 0xD800)
1391 #define UTF_16_LOW_SURROGATE_P(val) \
1392 (((val) & 0xFC00) == 0xDC00)
1394 #define UTF_16_INVALID_P(val) \
1395 (((val) == 0xFFFE) \
1396 || ((val) == 0xFFFF) \
1397 || UTF_16_LOW_SURROGATE_P (val))
1401 detect_coding_utf_16 (coding
, detect_info
)
1402 struct coding_system
*coding
;
1403 struct coding_detection_info
*detect_info
;
1405 const unsigned char *src
= coding
->source
, *src_base
= src
;
1406 const unsigned char *src_end
= coding
->source
+ coding
->src_bytes
;
1407 int multibytep
= coding
->src_multibyte
;
1408 int consumed_chars
= 0;
1411 detect_info
->checked
|= CATEGORY_MASK_UTF_16
;
1412 if (coding
->mode
& CODING_MODE_LAST_BLOCK
1413 && (coding
->src_chars
& 1))
1415 detect_info
->rejected
|= CATEGORY_MASK_UTF_16
;
1421 if ((c1
== 0xFF) && (c2
== 0xFE))
1423 detect_info
->found
|= (CATEGORY_MASK_UTF_16_LE
1424 | CATEGORY_MASK_UTF_16_AUTO
);
1425 detect_info
->rejected
|= (CATEGORY_MASK_UTF_16_BE
1426 | CATEGORY_MASK_UTF_16_BE_NOSIG
1427 | CATEGORY_MASK_UTF_16_LE_NOSIG
);
1429 else if ((c1
== 0xFE) && (c2
== 0xFF))
1431 detect_info
->found
|= (CATEGORY_MASK_UTF_16_BE
1432 | CATEGORY_MASK_UTF_16_AUTO
);
1433 detect_info
->rejected
|= (CATEGORY_MASK_UTF_16_LE
1434 | CATEGORY_MASK_UTF_16_BE_NOSIG
1435 | CATEGORY_MASK_UTF_16_LE_NOSIG
);
1437 else if (c1
>= 0 && c2
>= 0)
1439 detect_info
->rejected
1440 |= (CATEGORY_MASK_UTF_16_BE
| CATEGORY_MASK_UTF_16_LE
);
1447 decode_coding_utf_16 (coding
)
1448 struct coding_system
*coding
;
1450 const unsigned char *src
= coding
->source
+ coding
->consumed
;
1451 const unsigned char *src_end
= coding
->source
+ coding
->src_bytes
;
1452 const unsigned char *src_base
;
1453 int *charbuf
= coding
->charbuf
+ coding
->charbuf_used
;
1454 int *charbuf_end
= coding
->charbuf
+ coding
->charbuf_size
;
1455 int consumed_chars
= 0, consumed_chars_base
;
1456 int multibytep
= coding
->src_multibyte
;
1457 enum utf_16_bom_type bom
= CODING_UTF_16_BOM (coding
);
1458 enum utf_16_endian_type endian
= CODING_UTF_16_ENDIAN (coding
);
1459 int surrogate
= CODING_UTF_16_SURROGATE (coding
);
1460 Lisp_Object attr
, charset_list
;
1462 CODING_GET_INFO (coding
, attr
, charset_list
);
1464 if (bom
== utf_16_with_bom
)
1473 if (endian
== utf_16_big_endian
1474 ? c
!= 0xFEFF : c
!= 0xFFFE)
1476 /* The first two bytes are not BOM. Treat them as bytes
1477 for a normal character. */
1481 CODING_UTF_16_BOM (coding
) = utf_16_without_bom
;
1483 else if (bom
== utf_16_detect_bom
)
1485 /* We have already tried to detect BOM and failed in
1487 CODING_UTF_16_BOM (coding
) = utf_16_without_bom
;
1495 consumed_chars_base
= consumed_chars
;
1497 if (charbuf
+ 2 >= charbuf_end
)
1509 *charbuf
++ = ASCII_BYTE_P (c1
) ? c1
: BYTE8_TO_CHAR (c1
);
1513 c
= (endian
== utf_16_big_endian
1514 ? ((c1
<< 8) | c2
) : ((c2
<< 8) | c1
));
1517 if (! UTF_16_LOW_SURROGATE_P (c
))
1519 if (endian
== utf_16_big_endian
)
1520 c1
= surrogate
>> 8, c2
= surrogate
& 0xFF;
1522 c1
= surrogate
& 0xFF, c2
= surrogate
>> 8;
1526 if (UTF_16_HIGH_SURROGATE_P (c
))
1527 CODING_UTF_16_SURROGATE (coding
) = surrogate
= c
;
1533 c
= ((surrogate
- 0xD800) << 10) | (c
- 0xDC00);
1534 CODING_UTF_16_SURROGATE (coding
) = surrogate
= 0;
1535 *charbuf
++ = 0x10000 + c
;
1540 if (UTF_16_HIGH_SURROGATE_P (c
))
1541 CODING_UTF_16_SURROGATE (coding
) = surrogate
= c
;
1548 coding
->consumed_char
+= consumed_chars_base
;
1549 coding
->consumed
= src_base
- coding
->source
;
1550 coding
->charbuf_used
= charbuf
- coding
->charbuf
;
1554 encode_coding_utf_16 (coding
)
1555 struct coding_system
*coding
;
1557 int multibytep
= coding
->dst_multibyte
;
1558 int *charbuf
= coding
->charbuf
;
1559 int *charbuf_end
= charbuf
+ coding
->charbuf_used
;
1560 unsigned char *dst
= coding
->destination
+ coding
->produced
;
1561 unsigned char *dst_end
= coding
->destination
+ coding
->dst_bytes
;
1563 enum utf_16_bom_type bom
= CODING_UTF_16_BOM (coding
);
1564 int big_endian
= CODING_UTF_16_ENDIAN (coding
) == utf_16_big_endian
;
1565 int produced_chars
= 0;
1566 Lisp_Object attrs
, charset_list
;
1569 CODING_GET_INFO (coding
, attrs
, charset_list
);
1571 if (bom
!= utf_16_without_bom
)
1573 ASSURE_DESTINATION (safe_room
);
1575 EMIT_TWO_BYTES (0xFE, 0xFF);
1577 EMIT_TWO_BYTES (0xFF, 0xFE);
1578 CODING_UTF_16_BOM (coding
) = utf_16_without_bom
;
1581 while (charbuf
< charbuf_end
)
1583 ASSURE_DESTINATION (safe_room
);
1585 if (c
>= MAX_UNICODE_CHAR
)
1586 c
= coding
->default_char
;
1591 EMIT_TWO_BYTES (c
>> 8, c
& 0xFF);
1593 EMIT_TWO_BYTES (c
& 0xFF, c
>> 8);
1600 c1
= (c
>> 10) + 0xD800;
1601 c2
= (c
& 0x3FF) + 0xDC00;
1603 EMIT_FOUR_BYTES (c1
>> 8, c1
& 0xFF, c2
>> 8, c2
& 0xFF);
1605 EMIT_FOUR_BYTES (c1
& 0xFF, c1
>> 8, c2
& 0xFF, c2
>> 8);
1608 record_conversion_result (coding
, CODING_RESULT_SUCCESS
);
1609 coding
->produced
= dst
- coding
->destination
;
1610 coding
->produced_char
+= produced_chars
;
1615 /*** 6. Old Emacs' internal format (emacs-mule) ***/
1617 /* Emacs' internal format for representation of multiple character
1618 sets is a kind of multi-byte encoding, i.e. characters are
1619 represented by variable-length sequences of one-byte codes.
1621 ASCII characters and control characters (e.g. `tab', `newline') are
1622 represented by one-byte sequences which are their ASCII codes, in
1623 the range 0x00 through 0x7F.
1625 8-bit characters of the range 0x80..0x9F are represented by
1626 two-byte sequences of LEADING_CODE_8_BIT_CONTROL and (their 8-bit
1629 8-bit characters of the range 0xA0..0xFF are represented by
1630 one-byte sequences which are their 8-bit code.
1632 The other characters are represented by a sequence of `base
1633 leading-code', optional `extended leading-code', and one or two
1634 `position-code's. The length of the sequence is determined by the
1635 base leading-code. Leading-code takes the range 0x81 through 0x9D,
1636 whereas extended leading-code and position-code take the range 0xA0
1637 through 0xFF. See `charset.h' for more details about leading-code
1640 --- CODE RANGE of Emacs' internal format ---
1644 eight-bit-control LEADING_CODE_8_BIT_CONTROL + 0xA0..0xBF
1645 eight-bit-graphic 0xA0..0xBF
1646 ELSE 0x81..0x9D + [0xA0..0xFF]+
1647 ---------------------------------------------
1649 As this is the internal character representation, the format is
1650 usually not used externally (i.e. in a file or in a data sent to a
1651 process). But, it is possible to have a text externally in this
1652 format (i.e. by encoding by the coding system `emacs-mule').
1654 In that case, a sequence of one-byte codes has a slightly different
1657 At first, all characters in eight-bit-control are represented by
1658 one-byte sequences which are their 8-bit code.
1660 Next, character composition data are represented by the byte
1661 sequence of the form: 0x80 METHOD BYTES CHARS COMPONENT ...,
1663 METHOD is 0xF0 plus one of composition method (enum
1664 composition_method),
1666 BYTES is 0xA0 plus a byte length of this composition data,
1668 CHARS is 0x20 plus a number of characters composed by this
1671 COMPONENTs are characters of multibye form or composition
1672 rules encoded by two-byte of ASCII codes.
1674 In addition, for backward compatibility, the following formats are
1675 also recognized as composition data on decoding.
1678 0x80 0xFF MSEQ RULE MSEQ RULE ... MSEQ
1681 MSEQ is a multibyte form but in these special format:
1682 ASCII: 0xA0 ASCII_CODE+0x80,
1683 other: LEADING_CODE+0x20 FOLLOWING-BYTE ...,
1684 RULE is a one byte code of the range 0xA0..0xF0 that
1685 represents a composition rule.
1688 char emacs_mule_bytes
[256];
1691 emacs_mule_char (coding
, src
, nbytes
, nchars
, id
)
1692 struct coding_system
*coding
;
1693 const unsigned char *src
;
1694 int *nbytes
, *nchars
, *id
;
1696 const unsigned char *src_end
= coding
->source
+ coding
->src_bytes
;
1697 const unsigned char *src_base
= src
;
1698 int multibytep
= coding
->src_multibyte
;
1699 struct charset
*charset
;
1702 int consumed_chars
= 0;
1708 charset
= emacs_mule_charset
[0];
1714 /* Old style component character of a compostion. */
1724 switch (emacs_mule_bytes
[c
])
1727 if (! (charset
= emacs_mule_charset
[c
]))
1736 if (c
== EMACS_MULE_LEADING_CODE_PRIVATE_11
1737 || c
== EMACS_MULE_LEADING_CODE_PRIVATE_12
)
1740 if (c
< 0xA0 || ! (charset
= emacs_mule_charset
[c
]))
1749 if (! (charset
= emacs_mule_charset
[c
]))
1754 code
= (c
& 0x7F) << 8;
1764 if (c
< 0 || ! (charset
= emacs_mule_charset
[c
]))
1769 code
= (c
& 0x7F) << 8;
1778 charset
= CHARSET_FROM_ID (ASCII_BYTE_P (code
)
1779 ? charset_ascii
: charset_eight_bit
);
1785 c
= DECODE_CHAR (charset
, code
);
1789 *nbytes
= src
- src_base
;
1790 *nchars
= consumed_chars
;
1803 /* See the above "GENERAL NOTES on `detect_coding_XXX ()' functions".
1804 Check if a text is encoded in `emacs-mule'. If it is, return 1,
1808 detect_coding_emacs_mule (coding
, detect_info
)
1809 struct coding_system
*coding
;
1810 struct coding_detection_info
*detect_info
;
1812 const unsigned char *src
= coding
->source
, *src_base
;
1813 const unsigned char *src_end
= coding
->source
+ coding
->src_bytes
;
1814 int multibytep
= coding
->src_multibyte
;
1815 int consumed_chars
= 0;
1819 detect_info
->checked
|= CATEGORY_MASK_EMACS_MULE
;
1820 /* A coding system of this category is always ASCII compatible. */
1821 src
+= coding
->head_ascii
;
1831 /* Perhaps the start of composite character. We simple skip
1832 it because analyzing it is too heavy for detecting. But,
1833 at least, we check that the composite character
1834 constitues of more than 4 bytes. */
1835 const unsigned char *src_base
;
1845 if (src
- src_base
<= 4)
1847 found
= CATEGORY_MASK_EMACS_MULE
;
1855 && (c
== ISO_CODE_ESC
|| c
== ISO_CODE_SI
|| c
== ISO_CODE_SO
))
1860 int more_bytes
= emacs_mule_bytes
[*src_base
] - 1;
1862 while (more_bytes
> 0)
1867 src
--; /* Unread the last byte. */
1872 if (more_bytes
!= 0)
1874 found
= CATEGORY_MASK_EMACS_MULE
;
1877 detect_info
->rejected
|= CATEGORY_MASK_EMACS_MULE
;
1881 if (src_base
< src
&& coding
->mode
& CODING_MODE_LAST_BLOCK
)
1883 detect_info
->rejected
|= CATEGORY_MASK_EMACS_MULE
;
1886 detect_info
->found
|= found
;
1891 /* See the above "GENERAL NOTES on `decode_coding_XXX ()' functions". */
1893 /* Decode a character represented as a component of composition
1894 sequence of Emacs 20/21 style at SRC. Set C to that character and
1895 update SRC to the head of next character (or an encoded composition
1896 rule). If SRC doesn't points a composition component, set C to -1.
1897 If SRC points an invalid byte sequence, global exit by a return
1900 #define DECODE_EMACS_MULE_COMPOSITION_CHAR(buf) \
1904 int nbytes, nchars; \
1906 if (src == src_end) \
1908 c = emacs_mule_char (coding, src, &nbytes, &nchars, NULL);\
1913 goto invalid_code; \
1917 consumed_chars += nchars; \
1922 /* Decode a composition rule represented as a component of composition
1923 sequence of Emacs 20 style at SRC. Store the decoded rule in *BUF,
1924 and increment BUF. If SRC points an invalid byte sequence, set C
1927 #define DECODE_EMACS_MULE_COMPOSITION_RULE_20(buf) \
1929 int c, gref, nref; \
1931 if (src >= src_end) \
1932 goto invalid_code; \
1933 ONE_MORE_BYTE_NO_CHECK (c); \
1935 if (c < 0 || c >= 81) \
1936 goto invalid_code; \
1938 gref = c / 9, nref = c % 9; \
1939 *buf++ = COMPOSITION_ENCODE_RULE (gref, nref); \
1943 /* Decode a composition rule represented as a component of composition
1944 sequence of Emacs 21 style at SRC. Store the decoded rule in *BUF,
1945 and increment BUF. If SRC points an invalid byte sequence, set C
1948 #define DECODE_EMACS_MULE_COMPOSITION_RULE_21(buf) \
1952 if (src + 1>= src_end) \
1953 goto invalid_code; \
1954 ONE_MORE_BYTE_NO_CHECK (gref); \
1956 ONE_MORE_BYTE_NO_CHECK (nref); \
1958 if (gref < 0 || gref >= 81 \
1959 || nref < 0 || nref >= 81) \
1960 goto invalid_code; \
1961 *buf++ = COMPOSITION_ENCODE_RULE (gref, nref); \
1965 #define DECODE_EMACS_MULE_21_COMPOSITION(c) \
1967 /* Emacs 21 style format. The first three bytes at SRC are \
1968 (METHOD - 0xF2), (BYTES - 0xA0), (CHARS - 0xA0), where BYTES is \
1969 the byte length of this composition information, CHARS is the \
1970 number of characters composed by this composition. */ \
1971 enum composition_method method = c - 0xF2; \
1972 int *charbuf_base = charbuf; \
1973 int consumed_chars_limit; \
1974 int nbytes, nchars; \
1976 ONE_MORE_BYTE (c); \
1978 goto invalid_code; \
1979 nbytes = c - 0xA0; \
1981 goto invalid_code; \
1982 ONE_MORE_BYTE (c); \
1984 goto invalid_code; \
1985 nchars = c - 0xA0; \
1986 ADD_COMPOSITION_DATA (charbuf, nchars, method); \
1987 consumed_chars_limit = consumed_chars_base + nbytes; \
1988 if (method != COMPOSITION_RELATIVE) \
1991 while (consumed_chars < consumed_chars_limit) \
1993 if (i % 2 && method != COMPOSITION_WITH_ALTCHARS) \
1994 DECODE_EMACS_MULE_COMPOSITION_RULE_21 (charbuf); \
1996 DECODE_EMACS_MULE_COMPOSITION_CHAR (charbuf); \
1999 if (consumed_chars < consumed_chars_limit) \
2000 goto invalid_code; \
2001 charbuf_base[0] -= i; \
2006 #define DECODE_EMACS_MULE_20_RELATIVE_COMPOSITION(c) \
2008 /* Emacs 20 style format for relative composition. */ \
2009 /* Store multibyte form of characters to be composed. */ \
2010 enum composition_method method = COMPOSITION_RELATIVE; \
2011 int components[MAX_COMPOSITION_COMPONENTS * 2 - 1]; \
2012 int *buf = components; \
2016 ONE_MORE_BYTE (c); /* skip 0x80 */ \
2017 for (i = 0; *src >= 0xA0 && i < MAX_COMPOSITION_COMPONENTS; i++) \
2018 DECODE_EMACS_MULE_COMPOSITION_CHAR (buf); \
2020 goto invalid_code; \
2021 ADD_COMPOSITION_DATA (charbuf, i, method); \
2022 for (j = 0; j < i; j++) \
2023 *charbuf++ = components[j]; \
2027 #define DECODE_EMACS_MULE_20_RULEBASE_COMPOSITION(c) \
2029 /* Emacs 20 style format for rule-base composition. */ \
2030 /* Store multibyte form of characters to be composed. */ \
2031 enum composition_method method = COMPOSITION_WITH_RULE; \
2032 int *charbuf_base = charbuf; \
2033 int components[MAX_COMPOSITION_COMPONENTS * 2 - 1]; \
2034 int *buf = components; \
2037 DECODE_EMACS_MULE_COMPOSITION_CHAR (buf); \
2038 for (i = 1; i < MAX_COMPOSITION_COMPONENTS; i++) \
2042 DECODE_EMACS_MULE_COMPOSITION_RULE_20 (buf); \
2043 DECODE_EMACS_MULE_COMPOSITION_CHAR (buf); \
2045 if (i <= 1 || (buf - components) % 2 == 0) \
2046 goto invalid_code; \
2047 if (charbuf + i + (i / 2) + 1 >= charbuf_end) \
2048 goto no_more_source; \
2049 ADD_COMPOSITION_DATA (charbuf, i, method); \
2051 for (j = 0; j < i; j++) \
2052 *charbuf++ = components[j]; \
2053 charbuf_base[0] -= i; \
2054 for (j = 0; j < i; j += 2) \
2055 *charbuf++ = components[j]; \
2060 decode_coding_emacs_mule (coding
)
2061 struct coding_system
*coding
;
2063 const unsigned char *src
= coding
->source
+ coding
->consumed
;
2064 const unsigned char *src_end
= coding
->source
+ coding
->src_bytes
;
2065 const unsigned char *src_base
;
2066 int *charbuf
= coding
->charbuf
+ coding
->charbuf_used
;
2068 = coding
->charbuf
+ coding
->charbuf_size
- MAX_ANNOTATION_LENGTH
;
2069 int consumed_chars
= 0, consumed_chars_base
;
2070 int multibytep
= coding
->src_multibyte
;
2071 Lisp_Object attrs
, charset_list
;
2072 int char_offset
= coding
->produced_char
;
2073 int last_offset
= char_offset
;
2074 int last_id
= charset_ascii
;
2076 CODING_GET_INFO (coding
, attrs
, charset_list
);
2083 consumed_chars_base
= consumed_chars
;
2085 if (charbuf
>= charbuf_end
)
2104 if (c
- 0xF2 >= COMPOSITION_RELATIVE
2105 && c
- 0xF2 <= COMPOSITION_WITH_RULE_ALTCHARS
)
2106 DECODE_EMACS_MULE_21_COMPOSITION (c
);
2108 DECODE_EMACS_MULE_20_RELATIVE_COMPOSITION (c
);
2110 DECODE_EMACS_MULE_20_RULEBASE_COMPOSITION (c
);
2114 else if (c
< 0xA0 && emacs_mule_bytes
[c
] > 1)
2120 consumed_chars
= consumed_chars_base
;
2121 c
= emacs_mule_char (coding
, src
, &nbytes
, &nchars
, &id
);
2130 if (last_id
!= charset_ascii
)
2131 ADD_CHARSET_DATA (charbuf
, char_offset
- last_offset
, last_id
);
2133 last_offset
= char_offset
;
2137 consumed_chars
+= nchars
;
2146 consumed_chars
= consumed_chars_base
;
2148 *charbuf
++ = ASCII_BYTE_P (c
) ? c
: BYTE8_TO_CHAR (c
);
2154 if (last_id
!= charset_ascii
)
2155 ADD_CHARSET_DATA (charbuf
, char_offset
- last_offset
, last_id
);
2156 coding
->consumed_char
+= consumed_chars_base
;
2157 coding
->consumed
= src_base
- coding
->source
;
2158 coding
->charbuf_used
= charbuf
- coding
->charbuf
;
2162 #define EMACS_MULE_LEADING_CODES(id, codes) \
2165 codes[0] = id, codes[1] = 0; \
2166 else if (id < 0xE0) \
2167 codes[0] = 0x9A, codes[1] = id; \
2168 else if (id < 0xF0) \
2169 codes[0] = 0x9B, codes[1] = id; \
2170 else if (id < 0xF5) \
2171 codes[0] = 0x9C, codes[1] = id; \
2173 codes[0] = 0x9D, codes[1] = id; \
2178 encode_coding_emacs_mule (coding
)
2179 struct coding_system
*coding
;
2181 int multibytep
= coding
->dst_multibyte
;
2182 int *charbuf
= coding
->charbuf
;
2183 int *charbuf_end
= charbuf
+ coding
->charbuf_used
;
2184 unsigned char *dst
= coding
->destination
+ coding
->produced
;
2185 unsigned char *dst_end
= coding
->destination
+ coding
->dst_bytes
;
2187 int produced_chars
= 0;
2188 Lisp_Object attrs
, charset_list
;
2190 int preferred_charset_id
= -1;
2192 CODING_GET_INFO (coding
, attrs
, charset_list
);
2193 if (! EQ (charset_list
, Vemacs_mule_charset_list
))
2195 CODING_ATTR_CHARSET_LIST (attrs
)
2196 = charset_list
= Vemacs_mule_charset_list
;
2199 while (charbuf
< charbuf_end
)
2201 ASSURE_DESTINATION (safe_room
);
2206 /* Handle an annotation. */
2209 case CODING_ANNOTATE_COMPOSITION_MASK
:
2210 /* Not yet implemented. */
2212 case CODING_ANNOTATE_CHARSET_MASK
:
2213 preferred_charset_id
= charbuf
[3];
2214 if (preferred_charset_id
>= 0
2215 && NILP (Fmemq (make_number (preferred_charset_id
),
2217 preferred_charset_id
= -1;
2226 if (ASCII_CHAR_P (c
))
2227 EMIT_ONE_ASCII_BYTE (c
);
2228 else if (CHAR_BYTE8_P (c
))
2230 c
= CHAR_TO_BYTE8 (c
);
2235 struct charset
*charset
;
2239 unsigned char leading_codes
[2];
2241 if (preferred_charset_id
>= 0)
2243 charset
= CHARSET_FROM_ID (preferred_charset_id
);
2244 if (! CHAR_CHARSET_P (c
, charset
))
2245 charset
= char_charset (c
, charset_list
, NULL
);
2248 charset
= char_charset (c
, charset_list
, &code
);
2251 c
= coding
->default_char
;
2252 if (ASCII_CHAR_P (c
))
2254 EMIT_ONE_ASCII_BYTE (c
);
2257 charset
= char_charset (c
, charset_list
, &code
);
2259 dimension
= CHARSET_DIMENSION (charset
);
2260 emacs_mule_id
= CHARSET_EMACS_MULE_ID (charset
);
2261 EMACS_MULE_LEADING_CODES (emacs_mule_id
, leading_codes
);
2262 EMIT_ONE_BYTE (leading_codes
[0]);
2263 if (leading_codes
[1])
2264 EMIT_ONE_BYTE (leading_codes
[1]);
2266 EMIT_ONE_BYTE (code
| 0x80);
2270 EMIT_ONE_BYTE (code
>> 8);
2271 EMIT_ONE_BYTE (code
& 0xFF);
2275 record_conversion_result (coding
, CODING_RESULT_SUCCESS
);
2276 coding
->produced_char
+= produced_chars
;
2277 coding
->produced
= dst
- coding
->destination
;
2282 /*** 7. ISO2022 handlers ***/
2284 /* The following note describes the coding system ISO2022 briefly.
2285 Since the intention of this note is to help understand the
2286 functions in this file, some parts are NOT ACCURATE or are OVERLY
2287 SIMPLIFIED. For thorough understanding, please refer to the
2288 original document of ISO2022. This is equivalent to the standard
2289 ECMA-35, obtainable from <URL:http://www.ecma.ch/> (*).
2291 ISO2022 provides many mechanisms to encode several character sets
2292 in 7-bit and 8-bit environments. For 7-bit environments, all text
2293 is encoded using bytes less than 128. This may make the encoded
2294 text a little bit longer, but the text passes more easily through
2295 several types of gateway, some of which strip off the MSB (Most
2298 There are two kinds of character sets: control character sets and
2299 graphic character sets. The former contain control characters such
2300 as `newline' and `escape' to provide control functions (control
2301 functions are also provided by escape sequences). The latter
2302 contain graphic characters such as 'A' and '-'. Emacs recognizes
2303 two control character sets and many graphic character sets.
2305 Graphic character sets are classified into one of the following
2306 four classes, according to the number of bytes (DIMENSION) and
2307 number of characters in one dimension (CHARS) of the set:
2308 - DIMENSION1_CHARS94
2309 - DIMENSION1_CHARS96
2310 - DIMENSION2_CHARS94
2311 - DIMENSION2_CHARS96
2313 In addition, each character set is assigned an identification tag,
2314 unique for each set, called the "final character" (denoted as <F>
2315 hereafter). The <F> of each character set is decided by ECMA(*)
2316 when it is registered in ISO. The code range of <F> is 0x30..0x7F
2317 (0x30..0x3F are for private use only).
2319 Note (*): ECMA = European Computer Manufacturers Association
2321 Here are examples of graphic character sets [NAME(<F>)]:
2322 o DIMENSION1_CHARS94 -- ASCII('B'), right-half-of-JISX0201('I'), ...
2323 o DIMENSION1_CHARS96 -- right-half-of-ISO8859-1('A'), ...
2324 o DIMENSION2_CHARS94 -- GB2312('A'), JISX0208('B'), ...
2325 o DIMENSION2_CHARS96 -- none for the moment
2327 A code area (1 byte=8 bits) is divided into 4 areas, C0, GL, C1, and GR.
2328 C0 [0x00..0x1F] -- control character plane 0
2329 GL [0x20..0x7F] -- graphic character plane 0
2330 C1 [0x80..0x9F] -- control character plane 1
2331 GR [0xA0..0xFF] -- graphic character plane 1
2333 A control character set is directly designated and invoked to C0 or
2334 C1 by an escape sequence. The most common case is that:
2335 - ISO646's control character set is designated/invoked to C0, and
2336 - ISO6429's control character set is designated/invoked to C1,
2337 and usually these designations/invocations are omitted in encoded
2338 text. In a 7-bit environment, only C0 can be used, and a control
2339 character for C1 is encoded by an appropriate escape sequence to
2340 fit into the environment. All control characters for C1 are
2341 defined to have corresponding escape sequences.
2343 A graphic character set is at first designated to one of four
2344 graphic registers (G0 through G3), then these graphic registers are
2345 invoked to GL or GR. These designations and invocations can be
2346 done independently. The most common case is that G0 is invoked to
2347 GL, G1 is invoked to GR, and ASCII is designated to G0. Usually
2348 these invocations and designations are omitted in encoded text.
2349 In a 7-bit environment, only GL can be used.
2351 When a graphic character set of CHARS94 is invoked to GL, codes
2352 0x20 and 0x7F of the GL area work as control characters SPACE and
2353 DEL respectively, and codes 0xA0 and 0xFF of the GR area should not
2356 There are two ways of invocation: locking-shift and single-shift.
2357 With locking-shift, the invocation lasts until the next different
2358 invocation, whereas with single-shift, the invocation affects the
2359 following character only and doesn't affect the locking-shift
2360 state. Invocations are done by the following control characters or
2363 ----------------------------------------------------------------------
2364 abbrev function cntrl escape seq description
2365 ----------------------------------------------------------------------
2366 SI/LS0 (shift-in) 0x0F none invoke G0 into GL
2367 SO/LS1 (shift-out) 0x0E none invoke G1 into GL
2368 LS2 (locking-shift-2) none ESC 'n' invoke G2 into GL
2369 LS3 (locking-shift-3) none ESC 'o' invoke G3 into GL
2370 LS1R (locking-shift-1 right) none ESC '~' invoke G1 into GR (*)
2371 LS2R (locking-shift-2 right) none ESC '}' invoke G2 into GR (*)
2372 LS3R (locking-shift 3 right) none ESC '|' invoke G3 into GR (*)
2373 SS2 (single-shift-2) 0x8E ESC 'N' invoke G2 for one char
2374 SS3 (single-shift-3) 0x8F ESC 'O' invoke G3 for one char
2375 ----------------------------------------------------------------------
2376 (*) These are not used by any known coding system.
2378 Control characters for these functions are defined by macros
2379 ISO_CODE_XXX in `coding.h'.
2381 Designations are done by the following escape sequences:
2382 ----------------------------------------------------------------------
2383 escape sequence description
2384 ----------------------------------------------------------------------
2385 ESC '(' <F> designate DIMENSION1_CHARS94<F> to G0
2386 ESC ')' <F> designate DIMENSION1_CHARS94<F> to G1
2387 ESC '*' <F> designate DIMENSION1_CHARS94<F> to G2
2388 ESC '+' <F> designate DIMENSION1_CHARS94<F> to G3
2389 ESC ',' <F> designate DIMENSION1_CHARS96<F> to G0 (*)
2390 ESC '-' <F> designate DIMENSION1_CHARS96<F> to G1
2391 ESC '.' <F> designate DIMENSION1_CHARS96<F> to G2
2392 ESC '/' <F> designate DIMENSION1_CHARS96<F> to G3
2393 ESC '$' '(' <F> designate DIMENSION2_CHARS94<F> to G0 (**)
2394 ESC '$' ')' <F> designate DIMENSION2_CHARS94<F> to G1
2395 ESC '$' '*' <F> designate DIMENSION2_CHARS94<F> to G2
2396 ESC '$' '+' <F> designate DIMENSION2_CHARS94<F> to G3
2397 ESC '$' ',' <F> designate DIMENSION2_CHARS96<F> to G0 (*)
2398 ESC '$' '-' <F> designate DIMENSION2_CHARS96<F> to G1
2399 ESC '$' '.' <F> designate DIMENSION2_CHARS96<F> to G2
2400 ESC '$' '/' <F> designate DIMENSION2_CHARS96<F> to G3
2401 ----------------------------------------------------------------------
2403 In this list, "DIMENSION1_CHARS94<F>" means a graphic character set
2404 of dimension 1, chars 94, and final character <F>, etc...
2406 Note (*): Although these designations are not allowed in ISO2022,
2407 Emacs accepts them on decoding, and produces them on encoding
2408 CHARS96 character sets in a coding system which is characterized as
2409 7-bit environment, non-locking-shift, and non-single-shift.
2411 Note (**): If <F> is '@', 'A', or 'B', the intermediate character
2412 '(' must be omitted. We refer to this as "short-form" hereafter.
2414 Now you may notice that there are a lot of ways of encoding the
2415 same multilingual text in ISO2022. Actually, there exist many
2416 coding systems such as Compound Text (used in X11's inter client
2417 communication, ISO-2022-JP (used in Japanese Internet), ISO-2022-KR
2418 (used in Korean Internet), EUC (Extended UNIX Code, used in Asian
2419 localized platforms), and all of these are variants of ISO2022.
2421 In addition to the above, Emacs handles two more kinds of escape
2422 sequences: ISO6429's direction specification and Emacs' private
2423 sequence for specifying character composition.
2425 ISO6429's direction specification takes the following form:
2426 o CSI ']' -- end of the current direction
2427 o CSI '0' ']' -- end of the current direction
2428 o CSI '1' ']' -- start of left-to-right text
2429 o CSI '2' ']' -- start of right-to-left text
2430 The control character CSI (0x9B: control sequence introducer) is
2431 abbreviated to the escape sequence ESC '[' in a 7-bit environment.
2433 Character composition specification takes the following form:
2434 o ESC '0' -- start relative composition
2435 o ESC '1' -- end composition
2436 o ESC '2' -- start rule-base composition (*)
2437 o ESC '3' -- start relative composition with alternate chars (**)
2438 o ESC '4' -- start rule-base composition with alternate chars (**)
2439 Since these are not standard escape sequences of any ISO standard,
2440 the use of them with these meanings is restricted to Emacs only.
2442 (*) This form is used only in Emacs 20.7 and older versions,
2443 but newer versions can safely decode it.
2444 (**) This form is used only in Emacs 21.1 and newer versions,
2445 and older versions can't decode it.
2447 Here's a list of example usages of these composition escape
2448 sequences (categorized by `enum composition_method').
2450 COMPOSITION_RELATIVE:
2451 ESC 0 CHAR [ CHAR ] ESC 1
2452 COMPOSITION_WITH_RULE:
2453 ESC 2 CHAR [ RULE CHAR ] ESC 1
2454 COMPOSITION_WITH_ALTCHARS:
2455 ESC 3 ALTCHAR [ ALTCHAR ] ESC 0 CHAR [ CHAR ] ESC 1
2456 COMPOSITION_WITH_RULE_ALTCHARS:
2457 ESC 4 ALTCHAR [ RULE ALTCHAR ] ESC 0 CHAR [ CHAR ] ESC 1 */
2459 enum iso_code_class_type iso_code_class
[256];
2461 #define SAFE_CHARSET_P(coding, id) \
2462 ((id) <= (coding)->max_charset_id \
2463 && (coding)->safe_charsets[id] >= 0)
2466 #define SHIFT_OUT_OK(category) \
2467 (CODING_ISO_INITIAL (&coding_categories[category], 1) >= 0)
2470 setup_iso_safe_charsets (attrs
)
2473 Lisp_Object charset_list
, safe_charsets
;
2474 Lisp_Object request
;
2475 Lisp_Object reg_usage
;
2478 int flags
= XINT (AREF (attrs
, coding_attr_iso_flags
));
2481 charset_list
= CODING_ATTR_CHARSET_LIST (attrs
);
2482 if ((flags
& CODING_ISO_FLAG_FULL_SUPPORT
)
2483 && ! EQ (charset_list
, Viso_2022_charset_list
))
2485 CODING_ATTR_CHARSET_LIST (attrs
)
2486 = charset_list
= Viso_2022_charset_list
;
2487 ASET (attrs
, coding_attr_safe_charsets
, Qnil
);
2490 if (STRINGP (AREF (attrs
, coding_attr_safe_charsets
)))
2494 for (tail
= charset_list
; CONSP (tail
); tail
= XCDR (tail
))
2496 int id
= XINT (XCAR (tail
));
2497 if (max_charset_id
< id
)
2498 max_charset_id
= id
;
2501 safe_charsets
= Fmake_string (make_number (max_charset_id
+ 1),
2503 request
= AREF (attrs
, coding_attr_iso_request
);
2504 reg_usage
= AREF (attrs
, coding_attr_iso_usage
);
2505 reg94
= XINT (XCAR (reg_usage
));
2506 reg96
= XINT (XCDR (reg_usage
));
2508 for (tail
= charset_list
; CONSP (tail
); tail
= XCDR (tail
))
2512 struct charset
*charset
;
2515 charset
= CHARSET_FROM_ID (XINT (id
));
2516 reg
= Fcdr (Fassq (id
, request
));
2518 SSET (safe_charsets
, XINT (id
), XINT (reg
));
2519 else if (charset
->iso_chars_96
)
2522 SSET (safe_charsets
, XINT (id
), reg96
);
2527 SSET (safe_charsets
, XINT (id
), reg94
);
2530 ASET (attrs
, coding_attr_safe_charsets
, safe_charsets
);
2534 /* See the above "GENERAL NOTES on `detect_coding_XXX ()' functions".
2535 Check if a text is encoded in one of ISO-2022 based codig systems.
2536 If it is, return 1, else return 0. */
2539 detect_coding_iso_2022 (coding
, detect_info
)
2540 struct coding_system
*coding
;
2541 struct coding_detection_info
*detect_info
;
2543 const unsigned char *src
= coding
->source
, *src_base
= src
;
2544 const unsigned char *src_end
= coding
->source
+ coding
->src_bytes
;
2545 int multibytep
= coding
->src_multibyte
;
2546 int single_shifting
= 0;
2549 int consumed_chars
= 0;
2554 detect_info
->checked
|= CATEGORY_MASK_ISO
;
2556 for (i
= coding_category_iso_7
; i
<= coding_category_iso_8_else
; i
++)
2558 struct coding_system
*this = &(coding_categories
[i
]);
2559 Lisp_Object attrs
, val
;
2561 attrs
= CODING_ID_ATTRS (this->id
);
2562 if (CODING_ISO_FLAGS (this) & CODING_ISO_FLAG_FULL_SUPPORT
2563 && ! EQ (CODING_ATTR_SAFE_CHARSETS (attrs
), Viso_2022_charset_list
))
2564 setup_iso_safe_charsets (attrs
);
2565 val
= CODING_ATTR_SAFE_CHARSETS (attrs
);
2566 this->max_charset_id
= SCHARS (val
) - 1;
2567 this->safe_charsets
= (char *) SDATA (val
);
2570 /* A coding system of this category is always ASCII compatible. */
2571 src
+= coding
->head_ascii
;
2573 while (rejected
!= CATEGORY_MASK_ISO
)
2580 if (inhibit_iso_escape_detection
)
2582 single_shifting
= 0;
2584 if (c
>= '(' && c
<= '/')
2586 /* Designation sequence for a charset of dimension 1. */
2588 if (c1
< ' ' || c1
>= 0x80
2589 || (id
= iso_charset_table
[0][c
>= ','][c1
]) < 0)
2590 /* Invalid designation sequence. Just ignore. */
2595 /* Designation sequence for a charset of dimension 2. */
2597 if (c
>= '@' && c
<= 'B')
2598 /* Designation for JISX0208.1978, GB2312, or JISX0208. */
2599 id
= iso_charset_table
[1][0][c
];
2600 else if (c
>= '(' && c
<= '/')
2603 if (c1
< ' ' || c1
>= 0x80
2604 || (id
= iso_charset_table
[1][c
>= ','][c1
]) < 0)
2605 /* Invalid designation sequence. Just ignore. */
2609 /* Invalid designation sequence. Just ignore it. */
2612 else if (c
== 'N' || c
== 'O')
2614 /* ESC <Fe> for SS2 or SS3. */
2615 single_shifting
= 1;
2616 rejected
|= CATEGORY_MASK_ISO_7BIT
| CATEGORY_MASK_ISO_8BIT
;
2619 else if (c
>= '0' && c
<= '4')
2621 /* ESC <Fp> for start/end composition. */
2622 found
|= CATEGORY_MASK_ISO
;
2627 /* Invalid escape sequence. Just ignore it. */
2631 /* We found a valid designation sequence for CHARSET. */
2632 rejected
|= CATEGORY_MASK_ISO_8BIT
;
2633 if (SAFE_CHARSET_P (&coding_categories
[coding_category_iso_7
],
2635 found
|= CATEGORY_MASK_ISO_7
;
2637 rejected
|= CATEGORY_MASK_ISO_7
;
2638 if (SAFE_CHARSET_P (&coding_categories
[coding_category_iso_7_tight
],
2640 found
|= CATEGORY_MASK_ISO_7_TIGHT
;
2642 rejected
|= CATEGORY_MASK_ISO_7_TIGHT
;
2643 if (SAFE_CHARSET_P (&coding_categories
[coding_category_iso_7_else
],
2645 found
|= CATEGORY_MASK_ISO_7_ELSE
;
2647 rejected
|= CATEGORY_MASK_ISO_7_ELSE
;
2648 if (SAFE_CHARSET_P (&coding_categories
[coding_category_iso_8_else
],
2650 found
|= CATEGORY_MASK_ISO_8_ELSE
;
2652 rejected
|= CATEGORY_MASK_ISO_8_ELSE
;
2657 /* Locking shift out/in. */
2658 if (inhibit_iso_escape_detection
)
2660 single_shifting
= 0;
2661 rejected
|= CATEGORY_MASK_ISO_7BIT
| CATEGORY_MASK_ISO_8BIT
;
2665 /* Control sequence introducer. */
2666 single_shifting
= 0;
2667 rejected
|= CATEGORY_MASK_ISO_7BIT
| CATEGORY_MASK_ISO_7_ELSE
;
2668 found
|= CATEGORY_MASK_ISO_8_ELSE
;
2669 goto check_extra_latin
;
2674 if (inhibit_iso_escape_detection
)
2676 single_shifting
= 0;
2677 rejected
|= CATEGORY_MASK_ISO_7BIT
;
2678 if (CODING_ISO_FLAGS (&coding_categories
[coding_category_iso_8_1
])
2679 & CODING_ISO_FLAG_SINGLE_SHIFT
)
2680 found
|= CATEGORY_MASK_ISO_8_1
, single_shifting
= 1;
2681 if (CODING_ISO_FLAGS (&coding_categories
[coding_category_iso_8_2
])
2682 & CODING_ISO_FLAG_SINGLE_SHIFT
)
2683 found
|= CATEGORY_MASK_ISO_8_2
, single_shifting
= 1;
2684 if (single_shifting
)
2686 goto check_extra_latin
;
2693 single_shifting
= 0;
2698 rejected
|= CATEGORY_MASK_ISO_7BIT
| CATEGORY_MASK_ISO_7_ELSE
;
2699 found
|= CATEGORY_MASK_ISO_8_1
;
2700 /* Check the length of succeeding codes of the range
2701 0xA0..0FF. If the byte length is even, we include
2702 CATEGORY_MASK_ISO_8_2 in `found'. We can check this
2703 only when we are not single shifting. */
2704 if (! single_shifting
2705 && ! (rejected
& CATEGORY_MASK_ISO_8_2
))
2708 while (src
< src_end
)
2716 if (i
& 1 && src
< src_end
)
2717 rejected
|= CATEGORY_MASK_ISO_8_2
;
2719 found
|= CATEGORY_MASK_ISO_8_2
;
2724 single_shifting
= 0;
2725 if (! VECTORP (Vlatin_extra_code_table
)
2726 || NILP (XVECTOR (Vlatin_extra_code_table
)->contents
[c
]))
2728 rejected
= CATEGORY_MASK_ISO
;
2731 if (CODING_ISO_FLAGS (&coding_categories
[coding_category_iso_8_1
])
2732 & CODING_ISO_FLAG_LATIN_EXTRA
)
2733 found
|= CATEGORY_MASK_ISO_8_1
;
2735 rejected
|= CATEGORY_MASK_ISO_8_1
;
2736 rejected
|= CATEGORY_MASK_ISO_8_2
;
2739 detect_info
->rejected
|= CATEGORY_MASK_ISO
;
2743 detect_info
->rejected
|= rejected
;
2744 detect_info
->found
|= (found
& ~rejected
);
2749 /* Set designation state into CODING. Set CHARS_96 to -1 if the
2750 escape sequence should be kept. */
2751 #define DECODE_DESIGNATION(reg, dim, chars_96, final) \
2755 if (final < '0' || final >= 128 \
2756 || ((id = ISO_CHARSET_TABLE (dim, chars_96, final)) < 0) \
2757 || !SAFE_CHARSET_P (coding, id)) \
2759 CODING_ISO_DESIGNATION (coding, reg) = -2; \
2763 prev = CODING_ISO_DESIGNATION (coding, reg); \
2764 if (id == charset_jisx0201_roman) \
2766 if (CODING_ISO_FLAGS (coding) & CODING_ISO_FLAG_USE_ROMAN) \
2767 id = charset_ascii; \
2769 else if (id == charset_jisx0208_1978) \
2771 if (CODING_ISO_FLAGS (coding) & CODING_ISO_FLAG_USE_OLDJIS) \
2772 id = charset_jisx0208; \
2774 CODING_ISO_DESIGNATION (coding, reg) = id; \
2775 /* If there was an invalid designation to REG previously, and this \
2776 designation is ASCII to REG, we should keep this designation \
2778 if (prev == -2 && id == charset_ascii) \
2783 #define MAYBE_FINISH_COMPOSITION() \
2786 if (composition_state == COMPOSING_NO) \
2788 /* It is assured that we have enough room for producing \
2789 characters stored in the table `components'. */ \
2790 if (charbuf + component_idx > charbuf_end) \
2791 goto no_more_source; \
2792 composition_state = COMPOSING_NO; \
2793 if (method == COMPOSITION_RELATIVE \
2794 || method == COMPOSITION_WITH_ALTCHARS) \
2796 for (i = 0; i < component_idx; i++) \
2797 *charbuf++ = components[i]; \
2798 char_offset += component_idx; \
2802 for (i = 0; i < component_idx; i += 2) \
2803 *charbuf++ = components[i]; \
2804 char_offset += (component_idx / 2) + 1; \
2809 /* Handle composition start sequence ESC 0, ESC 2, ESC 3, or ESC 4.
2810 ESC 0 : relative composition : ESC 0 CHAR ... ESC 1
2811 ESC 2 : rulebase composition : ESC 2 CHAR RULE CHAR RULE ... CHAR ESC 1
2812 ESC 3 : altchar composition : ESC 3 CHAR ... ESC 0 CHAR ... ESC 1
2813 ESC 4 : alt&rule composition : ESC 4 CHAR RULE ... CHAR ESC 0 CHAR ... ESC 1
2816 #define DECODE_COMPOSITION_START(c1) \
2819 && composition_state == COMPOSING_COMPONENT_RULE) \
2821 component_len = component_idx; \
2822 composition_state = COMPOSING_CHAR; \
2826 const unsigned char *p; \
2828 MAYBE_FINISH_COMPOSITION (); \
2829 if (charbuf + MAX_COMPOSITION_COMPONENTS > charbuf_end) \
2830 goto no_more_source; \
2831 for (p = src; p < src_end - 1; p++) \
2832 if (*p == ISO_CODE_ESC && p[1] == '1') \
2834 if (p == src_end - 1) \
2836 /* The current composition doesn't end in the current \
2838 record_conversion_result \
2839 (coding, CODING_RESULT_INSUFFICIENT_SRC); \
2840 goto no_more_source; \
2843 /* This is surely the start of a composition. */ \
2844 method = (c1 == '0' ? COMPOSITION_RELATIVE \
2845 : c1 == '2' ? COMPOSITION_WITH_RULE \
2846 : c1 == '3' ? COMPOSITION_WITH_ALTCHARS \
2847 : COMPOSITION_WITH_RULE_ALTCHARS); \
2848 composition_state = (c1 <= '2' ? COMPOSING_CHAR \
2849 : COMPOSING_COMPONENT_CHAR); \
2850 component_idx = component_len = 0; \
2855 /* Handle compositoin end sequence ESC 1. */
2857 #define DECODE_COMPOSITION_END() \
2859 int nchars = (component_len > 0 ? component_idx - component_len \
2860 : method == COMPOSITION_RELATIVE ? component_idx \
2861 : (component_idx + 1) / 2); \
2863 int *saved_charbuf = charbuf; \
2865 ADD_COMPOSITION_DATA (charbuf, nchars, method); \
2866 if (method != COMPOSITION_RELATIVE) \
2868 if (component_len == 0) \
2869 for (i = 0; i < component_idx; i++) \
2870 *charbuf++ = components[i]; \
2872 for (i = 0; i < component_len; i++) \
2873 *charbuf++ = components[i]; \
2874 *saved_charbuf = saved_charbuf - charbuf; \
2876 if (method == COMPOSITION_WITH_RULE) \
2877 for (i = 0; i < component_idx; i += 2, char_offset++) \
2878 *charbuf++ = components[i]; \
2880 for (i = component_len; i < component_idx; i++, char_offset++) \
2881 *charbuf++ = components[i]; \
2882 coding->annotated = 1; \
2883 composition_state = COMPOSING_NO; \
2887 /* Decode a composition rule from the byte C1 (and maybe one more byte
2888 from SRC) and store one encoded composition rule in
2889 coding->cmp_data. */
2891 #define DECODE_COMPOSITION_RULE(c1) \
2894 if (c1 < 81) /* old format (before ver.21) */ \
2896 int gref = (c1) / 9; \
2897 int nref = (c1) % 9; \
2898 if (gref == 4) gref = 10; \
2899 if (nref == 4) nref = 10; \
2900 c1 = COMPOSITION_ENCODE_RULE (gref, nref); \
2902 else if (c1 < 93) /* new format (after ver.21) */ \
2904 ONE_MORE_BYTE (c2); \
2905 c1 = COMPOSITION_ENCODE_RULE (c1 - 81, c2 - 32); \
2912 /* See the above "GENERAL NOTES on `decode_coding_XXX ()' functions". */
2915 decode_coding_iso_2022 (coding
)
2916 struct coding_system
*coding
;
2918 const unsigned char *src
= coding
->source
+ coding
->consumed
;
2919 const unsigned char *src_end
= coding
->source
+ coding
->src_bytes
;
2920 const unsigned char *src_base
;
2921 int *charbuf
= coding
->charbuf
+ coding
->charbuf_used
;
2923 = coding
->charbuf
+ coding
->charbuf_size
- 4 - MAX_ANNOTATION_LENGTH
;
2924 int consumed_chars
= 0, consumed_chars_base
;
2925 int multibytep
= coding
->src_multibyte
;
2926 /* Charsets invoked to graphic plane 0 and 1 respectively. */
2927 int charset_id_0
= CODING_ISO_INVOKED_CHARSET (coding
, 0);
2928 int charset_id_1
= CODING_ISO_INVOKED_CHARSET (coding
, 1);
2929 int charset_id_2
, charset_id_3
;
2930 struct charset
*charset
;
2932 /* For handling composition sequence. */
2933 #define COMPOSING_NO 0
2934 #define COMPOSING_CHAR 1
2935 #define COMPOSING_RULE 2
2936 #define COMPOSING_COMPONENT_CHAR 3
2937 #define COMPOSING_COMPONENT_RULE 4
2939 int composition_state
= COMPOSING_NO
;
2940 enum composition_method method
;
2941 int components
[MAX_COMPOSITION_COMPONENTS
* 2 + 1];
2944 Lisp_Object attrs
, charset_list
;
2945 int char_offset
= coding
->produced_char
;
2946 int last_offset
= char_offset
;
2947 int last_id
= charset_ascii
;
2949 CODING_GET_INFO (coding
, attrs
, charset_list
);
2950 setup_iso_safe_charsets (attrs
);
2951 /* Charset list may have been changed. */
2952 charset_list
= CODING_ATTR_CHARSET_LIST (attrs
);
2953 coding
->safe_charsets
= (char *) SDATA (CODING_ATTR_SAFE_CHARSETS(attrs
));
2960 consumed_chars_base
= consumed_chars
;
2962 if (charbuf
>= charbuf_end
)
2969 /* We produce at most one character. */
2970 switch (iso_code_class
[c1
])
2972 case ISO_0x20_or_0x7F
:
2973 if (composition_state
!= COMPOSING_NO
)
2975 if (composition_state
== COMPOSING_RULE
2976 || composition_state
== COMPOSING_COMPONENT_RULE
)
2978 DECODE_COMPOSITION_RULE (c1
);
2979 components
[component_idx
++] = c1
;
2980 composition_state
--;
2984 if (charset_id_0
< 0
2985 || ! CHARSET_ISO_CHARS_96 (CHARSET_FROM_ID (charset_id_0
)))
2986 /* This is SPACE or DEL. */
2987 charset
= CHARSET_FROM_ID (charset_ascii
);
2989 charset
= CHARSET_FROM_ID (charset_id_0
);
2992 case ISO_graphic_plane_0
:
2993 if (composition_state
!= COMPOSING_NO
)
2995 if (composition_state
== COMPOSING_RULE
2996 || composition_state
== COMPOSING_COMPONENT_RULE
)
2998 DECODE_COMPOSITION_RULE (c1
);
2999 components
[component_idx
++] = c1
;
3000 composition_state
--;
3004 if (charset_id_0
< 0)
3005 charset
= CHARSET_FROM_ID (charset_ascii
);
3007 charset
= CHARSET_FROM_ID (charset_id_0
);
3010 case ISO_0xA0_or_0xFF
:
3011 if (charset_id_1
< 0
3012 || ! CHARSET_ISO_CHARS_96 (CHARSET_FROM_ID (charset_id_1
))
3013 || CODING_ISO_FLAGS (coding
) & CODING_ISO_FLAG_SEVEN_BITS
)
3015 /* This is a graphic character, we fall down ... */
3017 case ISO_graphic_plane_1
:
3018 if (charset_id_1
< 0)
3020 charset
= CHARSET_FROM_ID (charset_id_1
);
3024 MAYBE_FINISH_COMPOSITION ();
3025 charset
= CHARSET_FROM_ID (charset_ascii
);
3029 MAYBE_FINISH_COMPOSITION ();
3033 if (! (CODING_ISO_FLAGS (coding
) & CODING_ISO_FLAG_LOCKING_SHIFT
)
3034 || CODING_ISO_DESIGNATION (coding
, 1) < 0)
3036 CODING_ISO_INVOCATION (coding
, 0) = 1;
3037 charset_id_0
= CODING_ISO_INVOKED_CHARSET (coding
, 0);
3041 if (! (CODING_ISO_FLAGS (coding
) & CODING_ISO_FLAG_LOCKING_SHIFT
))
3043 CODING_ISO_INVOCATION (coding
, 0) = 0;
3044 charset_id_0
= CODING_ISO_INVOKED_CHARSET (coding
, 0);
3047 case ISO_single_shift_2_7
:
3048 case ISO_single_shift_2
:
3049 if (! (CODING_ISO_FLAGS (coding
) & CODING_ISO_FLAG_SINGLE_SHIFT
))
3051 /* SS2 is handled as an escape sequence of ESC 'N' */
3053 goto label_escape_sequence
;
3055 case ISO_single_shift_3
:
3056 if (! (CODING_ISO_FLAGS (coding
) & CODING_ISO_FLAG_SINGLE_SHIFT
))
3058 /* SS2 is handled as an escape sequence of ESC 'O' */
3060 goto label_escape_sequence
;
3062 case ISO_control_sequence_introducer
:
3063 /* CSI is handled as an escape sequence of ESC '[' ... */
3065 goto label_escape_sequence
;
3069 label_escape_sequence
:
3070 /* Escape sequences handled here are invocation,
3071 designation, direction specification, and character
3072 composition specification. */
3075 case '&': /* revision of following character set */
3077 if (!(c1
>= '@' && c1
<= '~'))
3080 if (c1
!= ISO_CODE_ESC
)
3083 goto label_escape_sequence
;
3085 case '$': /* designation of 2-byte character set */
3086 if (! (CODING_ISO_FLAGS (coding
) & CODING_ISO_FLAG_DESIGNATION
))
3092 if (c1
>= '@' && c1
<= 'B')
3093 { /* designation of JISX0208.1978, GB2312.1980,
3095 reg
= 0, chars96
= 0;
3097 else if (c1
>= 0x28 && c1
<= 0x2B)
3098 { /* designation of DIMENSION2_CHARS94 character set */
3099 reg
= c1
- 0x28, chars96
= 0;
3102 else if (c1
>= 0x2C && c1
<= 0x2F)
3103 { /* designation of DIMENSION2_CHARS96 character set */
3104 reg
= c1
- 0x2C, chars96
= 1;
3109 DECODE_DESIGNATION (reg
, 2, chars96
, c1
);
3110 /* We must update these variables now. */
3112 charset_id_0
= CODING_ISO_INVOKED_CHARSET (coding
, 0);
3114 charset_id_1
= CODING_ISO_INVOKED_CHARSET (coding
, 1);
3120 case 'n': /* invocation of locking-shift-2 */
3121 if (! (CODING_ISO_FLAGS (coding
) & CODING_ISO_FLAG_LOCKING_SHIFT
)
3122 || CODING_ISO_DESIGNATION (coding
, 2) < 0)
3124 CODING_ISO_INVOCATION (coding
, 0) = 2;
3125 charset_id_0
= CODING_ISO_INVOKED_CHARSET (coding
, 0);
3128 case 'o': /* invocation of locking-shift-3 */
3129 if (! (CODING_ISO_FLAGS (coding
) & CODING_ISO_FLAG_LOCKING_SHIFT
)
3130 || CODING_ISO_DESIGNATION (coding
, 3) < 0)
3132 CODING_ISO_INVOCATION (coding
, 0) = 3;
3133 charset_id_0
= CODING_ISO_INVOKED_CHARSET (coding
, 0);
3136 case 'N': /* invocation of single-shift-2 */
3137 if (! (CODING_ISO_FLAGS (coding
) & CODING_ISO_FLAG_SINGLE_SHIFT
)
3138 || CODING_ISO_DESIGNATION (coding
, 2) < 0)
3140 charset_id_2
= CODING_ISO_DESIGNATION (coding
, 2);
3141 if (charset_id_2
< 0)
3142 charset
= CHARSET_FROM_ID (charset_ascii
);
3144 charset
= CHARSET_FROM_ID (charset_id_2
);
3146 if (c1
< 0x20 || (c1
>= 0x80 && c1
< 0xA0))
3150 case 'O': /* invocation of single-shift-3 */
3151 if (! (CODING_ISO_FLAGS (coding
) & CODING_ISO_FLAG_SINGLE_SHIFT
)
3152 || CODING_ISO_DESIGNATION (coding
, 3) < 0)
3154 charset_id_3
= CODING_ISO_DESIGNATION (coding
, 3);
3155 if (charset_id_3
< 0)
3156 charset
= CHARSET_FROM_ID (charset_ascii
);
3158 charset
= CHARSET_FROM_ID (charset_id_3
);
3160 if (c1
< 0x20 || (c1
>= 0x80 && c1
< 0xA0))
3164 case '0': case '2': case '3': case '4': /* start composition */
3165 if (! (coding
->common_flags
& CODING_ANNOTATE_COMPOSITION_MASK
))
3167 DECODE_COMPOSITION_START (c1
);
3170 case '1': /* end composition */
3171 if (composition_state
== COMPOSING_NO
)
3173 DECODE_COMPOSITION_END ();
3176 case '[': /* specification of direction */
3177 if (! CODING_ISO_FLAGS (coding
) & CODING_ISO_FLAG_DIRECTION
)
3179 /* For the moment, nested direction is not supported.
3180 So, `coding->mode & CODING_MODE_DIRECTION' zero means
3181 left-to-right, and nozero means right-to-left. */
3185 case ']': /* end of the current direction */
3186 coding
->mode
&= ~CODING_MODE_DIRECTION
;
3188 case '0': /* end of the current direction */
3189 case '1': /* start of left-to-right direction */
3192 coding
->mode
&= ~CODING_MODE_DIRECTION
;
3197 case '2': /* start of right-to-left direction */
3200 coding
->mode
|= CODING_MODE_DIRECTION
;
3214 /* CTEXT extended segment:
3215 ESC % / [0-4] M L --ENCODING-NAME-- \002 --BYTES--
3216 We keep these bytes as is for the moment.
3217 They may be decoded by post-read-conversion. */
3221 ONE_MORE_BYTE (dim
);
3224 size
= ((M
- 128) * 128) + (L
- 128);
3225 if (charbuf
+ 8 + size
> charbuf_end
)
3227 *charbuf
++ = ISO_CODE_ESC
;
3231 *charbuf
++ = BYTE8_TO_CHAR (M
);
3232 *charbuf
++ = BYTE8_TO_CHAR (L
);
3236 *charbuf
++ = ASCII_BYTE_P (c1
) ? c1
: BYTE8_TO_CHAR (c1
);
3241 /* XFree86 extension for embedding UTF-8 in CTEXT:
3242 ESC % G --UTF-8-BYTES-- ESC % @
3243 We keep these bytes as is for the moment.
3244 They may be decoded by post-read-conversion. */
3247 if (p
+ 6 > charbuf_end
)
3249 *p
++ = ISO_CODE_ESC
;
3252 while (p
< charbuf_end
)
3255 if (c1
== ISO_CODE_ESC
3256 && src
+ 1 < src_end
3263 *p
++ = ASCII_BYTE_P (c1
) ? c1
: BYTE8_TO_CHAR (c1
);
3265 if (p
+ 3 > charbuf_end
)
3267 *p
++ = ISO_CODE_ESC
;
3278 if (! (CODING_ISO_FLAGS (coding
) & CODING_ISO_FLAG_DESIGNATION
))
3283 if (c1
>= 0x28 && c1
<= 0x2B)
3284 { /* designation of DIMENSION1_CHARS94 character set */
3285 reg
= c1
- 0x28, chars96
= 0;
3288 else if (c1
>= 0x2C && c1
<= 0x2F)
3289 { /* designation of DIMENSION1_CHARS96 character set */
3290 reg
= c1
- 0x2C, chars96
= 1;
3295 DECODE_DESIGNATION (reg
, 1, chars96
, c1
);
3296 /* We must update these variables now. */
3298 charset_id_0
= CODING_ISO_INVOKED_CHARSET (coding
, 0);
3300 charset_id_1
= CODING_ISO_INVOKED_CHARSET (coding
, 1);
3308 if (charset
->id
!= charset_ascii
3309 && last_id
!= charset
->id
)
3311 if (last_id
!= charset_ascii
)
3312 ADD_CHARSET_DATA (charbuf
, char_offset
- last_offset
, last_id
);
3313 last_id
= charset
->id
;
3314 last_offset
= char_offset
;
3317 /* Now we know CHARSET and 1st position code C1 of a character.
3318 Produce a decoded character while getting 2nd position code
3321 if (CHARSET_DIMENSION (charset
) > 1)
3324 if (c2
< 0x20 || (c2
>= 0x80 && c2
< 0xA0))
3325 /* C2 is not in a valid range. */
3327 c1
= (c1
<< 8) | (c2
& 0x7F);
3328 if (CHARSET_DIMENSION (charset
) > 2)
3331 if (c2
< 0x20 || (c2
>= 0x80 && c2
< 0xA0))
3332 /* C2 is not in a valid range. */
3334 c1
= (c1
<< 8) | (c2
& 0x7F);
3338 CODING_DECODE_CHAR (coding
, src
, src_base
, src_end
, charset
, c1
, c
);
3341 MAYBE_FINISH_COMPOSITION ();
3342 for (; src_base
< src
; src_base
++, char_offset
++)
3344 if (ASCII_BYTE_P (*src_base
))
3345 *charbuf
++ = *src_base
;
3347 *charbuf
++ = BYTE8_TO_CHAR (*src_base
);
3350 else if (composition_state
== COMPOSING_NO
)
3357 components
[component_idx
++] = c
;
3358 if (method
== COMPOSITION_WITH_RULE
3359 || (method
== COMPOSITION_WITH_RULE_ALTCHARS
3360 && composition_state
== COMPOSING_COMPONENT_CHAR
))
3361 composition_state
++;
3366 MAYBE_FINISH_COMPOSITION ();
3368 consumed_chars
= consumed_chars_base
;
3370 *charbuf
++ = c
< 0 ? -c
: ASCII_BYTE_P (c
) ? c
: BYTE8_TO_CHAR (c
);
3380 if (last_id
!= charset_ascii
)
3381 ADD_CHARSET_DATA (charbuf
, char_offset
- last_offset
, last_id
);
3382 coding
->consumed_char
+= consumed_chars_base
;
3383 coding
->consumed
= src_base
- coding
->source
;
3384 coding
->charbuf_used
= charbuf
- coding
->charbuf
;
3388 /* ISO2022 encoding stuff. */
3391 It is not enough to say just "ISO2022" on encoding, we have to
3392 specify more details. In Emacs, each coding system of ISO2022
3393 variant has the following specifications:
3394 1. Initial designation to G0 thru G3.
3395 2. Allows short-form designation?
3396 3. ASCII should be designated to G0 before control characters?
3397 4. ASCII should be designated to G0 at end of line?
3398 5. 7-bit environment or 8-bit environment?
3399 6. Use locking-shift?
3400 7. Use Single-shift?
3401 And the following two are only for Japanese:
3402 8. Use ASCII in place of JIS0201-1976-Roman?
3403 9. Use JISX0208-1983 in place of JISX0208-1978?
3404 These specifications are encoded in CODING_ISO_FLAGS (coding) as flag bits
3405 defined by macros CODING_ISO_FLAG_XXX. See `coding.h' for more
3409 /* Produce codes (escape sequence) for designating CHARSET to graphic
3410 register REG at DST, and increment DST. If <final-char> of CHARSET is
3411 '@', 'A', or 'B' and the coding system CODING allows, produce
3412 designation sequence of short-form. */
3414 #define ENCODE_DESIGNATION(charset, reg, coding) \
3416 unsigned char final_char = CHARSET_ISO_FINAL (charset); \
3417 char *intermediate_char_94 = "()*+"; \
3418 char *intermediate_char_96 = ",-./"; \
3419 int revision = -1; \
3422 if (CODING_ISO_FLAGS (coding) & CODING_ISO_FLAG_REVISION) \
3423 revision = CHARSET_ISO_REVISION (charset); \
3425 if (revision >= 0) \
3427 EMIT_TWO_ASCII_BYTES (ISO_CODE_ESC, '&'); \
3428 EMIT_ONE_BYTE ('@' + revision); \
3430 EMIT_ONE_ASCII_BYTE (ISO_CODE_ESC); \
3431 if (CHARSET_DIMENSION (charset) == 1) \
3433 if (! CHARSET_ISO_CHARS_96 (charset)) \
3434 c = intermediate_char_94[reg]; \
3436 c = intermediate_char_96[reg]; \
3437 EMIT_ONE_ASCII_BYTE (c); \
3441 EMIT_ONE_ASCII_BYTE ('$'); \
3442 if (! CHARSET_ISO_CHARS_96 (charset)) \
3444 if (CODING_ISO_FLAGS (coding) & CODING_ISO_FLAG_LONG_FORM \
3446 || final_char < '@' || final_char > 'B') \
3447 EMIT_ONE_ASCII_BYTE (intermediate_char_94[reg]); \
3450 EMIT_ONE_ASCII_BYTE (intermediate_char_96[reg]); \
3452 EMIT_ONE_ASCII_BYTE (final_char); \
3454 CODING_ISO_DESIGNATION (coding, reg) = CHARSET_ID (charset); \
3458 /* The following two macros produce codes (control character or escape
3459 sequence) for ISO2022 single-shift functions (single-shift-2 and
3462 #define ENCODE_SINGLE_SHIFT_2 \
3464 if (CODING_ISO_FLAGS (coding) & CODING_ISO_FLAG_SEVEN_BITS) \
3465 EMIT_TWO_ASCII_BYTES (ISO_CODE_ESC, 'N'); \
3467 EMIT_ONE_BYTE (ISO_CODE_SS2); \
3468 CODING_ISO_SINGLE_SHIFTING (coding) = 1; \
3472 #define ENCODE_SINGLE_SHIFT_3 \
3474 if (CODING_ISO_FLAGS (coding) & CODING_ISO_FLAG_SEVEN_BITS) \
3475 EMIT_TWO_ASCII_BYTES (ISO_CODE_ESC, 'O'); \
3477 EMIT_ONE_BYTE (ISO_CODE_SS3); \
3478 CODING_ISO_SINGLE_SHIFTING (coding) = 1; \
3482 /* The following four macros produce codes (control character or
3483 escape sequence) for ISO2022 locking-shift functions (shift-in,
3484 shift-out, locking-shift-2, and locking-shift-3). */
3486 #define ENCODE_SHIFT_IN \
3488 EMIT_ONE_ASCII_BYTE (ISO_CODE_SI); \
3489 CODING_ISO_INVOCATION (coding, 0) = 0; \
3493 #define ENCODE_SHIFT_OUT \
3495 EMIT_ONE_ASCII_BYTE (ISO_CODE_SO); \
3496 CODING_ISO_INVOCATION (coding, 0) = 1; \
3500 #define ENCODE_LOCKING_SHIFT_2 \
3502 EMIT_TWO_ASCII_BYTES (ISO_CODE_ESC, 'n'); \
3503 CODING_ISO_INVOCATION (coding, 0) = 2; \
3507 #define ENCODE_LOCKING_SHIFT_3 \
3509 EMIT_TWO_ASCII_BYTES (ISO_CODE_ESC, 'n'); \
3510 CODING_ISO_INVOCATION (coding, 0) = 3; \
3514 /* Produce codes for a DIMENSION1 character whose character set is
3515 CHARSET and whose position-code is C1. Designation and invocation
3516 sequences are also produced in advance if necessary. */
3518 #define ENCODE_ISO_CHARACTER_DIMENSION1(charset, c1) \
3520 int id = CHARSET_ID (charset); \
3522 if ((CODING_ISO_FLAGS (coding) & CODING_ISO_FLAG_USE_ROMAN) \
3523 && id == charset_ascii) \
3525 id = charset_jisx0201_roman; \
3526 charset = CHARSET_FROM_ID (id); \
3529 if (CODING_ISO_SINGLE_SHIFTING (coding)) \
3531 if (CODING_ISO_FLAGS (coding) & CODING_ISO_FLAG_SEVEN_BITS) \
3532 EMIT_ONE_ASCII_BYTE (c1 & 0x7F); \
3534 EMIT_ONE_BYTE (c1 | 0x80); \
3535 CODING_ISO_SINGLE_SHIFTING (coding) = 0; \
3538 else if (id == CODING_ISO_INVOKED_CHARSET (coding, 0)) \
3540 EMIT_ONE_ASCII_BYTE (c1 & 0x7F); \
3543 else if (id == CODING_ISO_INVOKED_CHARSET (coding, 1)) \
3545 EMIT_ONE_BYTE (c1 | 0x80); \
3549 /* Since CHARSET is not yet invoked to any graphic planes, we \
3550 must invoke it, or, at first, designate it to some graphic \
3551 register. Then repeat the loop to actually produce the \
3553 dst = encode_invocation_designation (charset, coding, dst, \
3558 /* Produce codes for a DIMENSION2 character whose character set is
3559 CHARSET and whose position-codes are C1 and C2. Designation and
3560 invocation codes are also produced in advance if necessary. */
3562 #define ENCODE_ISO_CHARACTER_DIMENSION2(charset, c1, c2) \
3564 int id = CHARSET_ID (charset); \
3566 if ((CODING_ISO_FLAGS (coding) & CODING_ISO_FLAG_USE_OLDJIS) \
3567 && id == charset_jisx0208) \
3569 id = charset_jisx0208_1978; \
3570 charset = CHARSET_FROM_ID (id); \
3573 if (CODING_ISO_SINGLE_SHIFTING (coding)) \
3575 if (CODING_ISO_FLAGS (coding) & CODING_ISO_FLAG_SEVEN_BITS) \
3576 EMIT_TWO_ASCII_BYTES ((c1) & 0x7F, (c2) & 0x7F); \
3578 EMIT_TWO_BYTES ((c1) | 0x80, (c2) | 0x80); \
3579 CODING_ISO_SINGLE_SHIFTING (coding) = 0; \
3582 else if (id == CODING_ISO_INVOKED_CHARSET (coding, 0)) \
3584 EMIT_TWO_ASCII_BYTES ((c1) & 0x7F, (c2) & 0x7F); \
3587 else if (id == CODING_ISO_INVOKED_CHARSET (coding, 1)) \
3589 EMIT_TWO_BYTES ((c1) | 0x80, (c2) | 0x80); \
3593 /* Since CHARSET is not yet invoked to any graphic planes, we \
3594 must invoke it, or, at first, designate it to some graphic \
3595 register. Then repeat the loop to actually produce the \
3597 dst = encode_invocation_designation (charset, coding, dst, \
3602 #define ENCODE_ISO_CHARACTER(charset, c) \
3604 int code = ENCODE_CHAR ((charset),(c)); \
3606 if (CHARSET_DIMENSION (charset) == 1) \
3607 ENCODE_ISO_CHARACTER_DIMENSION1 ((charset), code); \
3609 ENCODE_ISO_CHARACTER_DIMENSION2 ((charset), code >> 8, code & 0xFF); \
3613 /* Produce designation and invocation codes at a place pointed by DST
3614 to use CHARSET. The element `spec.iso_2022' of *CODING is updated.
3618 encode_invocation_designation (charset
, coding
, dst
, p_nchars
)
3619 struct charset
*charset
;
3620 struct coding_system
*coding
;
3624 int multibytep
= coding
->dst_multibyte
;
3625 int produced_chars
= *p_nchars
;
3626 int reg
; /* graphic register number */
3627 int id
= CHARSET_ID (charset
);
3629 /* At first, check designations. */
3630 for (reg
= 0; reg
< 4; reg
++)
3631 if (id
== CODING_ISO_DESIGNATION (coding
, reg
))
3636 /* CHARSET is not yet designated to any graphic registers. */
3637 /* At first check the requested designation. */
3638 reg
= CODING_ISO_REQUEST (coding
, id
);
3640 /* Since CHARSET requests no special designation, designate it
3641 to graphic register 0. */
3644 ENCODE_DESIGNATION (charset
, reg
, coding
);
3647 if (CODING_ISO_INVOCATION (coding
, 0) != reg
3648 && CODING_ISO_INVOCATION (coding
, 1) != reg
)
3650 /* Since the graphic register REG is not invoked to any graphic
3651 planes, invoke it to graphic plane 0. */
3654 case 0: /* graphic register 0 */
3658 case 1: /* graphic register 1 */
3662 case 2: /* graphic register 2 */
3663 if (CODING_ISO_FLAGS (coding
) & CODING_ISO_FLAG_SINGLE_SHIFT
)
3664 ENCODE_SINGLE_SHIFT_2
;
3666 ENCODE_LOCKING_SHIFT_2
;
3669 case 3: /* graphic register 3 */
3670 if (CODING_ISO_FLAGS (coding
) & CODING_ISO_FLAG_SINGLE_SHIFT
)
3671 ENCODE_SINGLE_SHIFT_3
;
3673 ENCODE_LOCKING_SHIFT_3
;
3678 *p_nchars
= produced_chars
;
3682 /* The following three macros produce codes for indicating direction
3684 #define ENCODE_CONTROL_SEQUENCE_INTRODUCER \
3686 if (CODING_ISO_FLAGS (coding) == CODING_ISO_FLAG_SEVEN_BITS) \
3687 EMIT_TWO_ASCII_BYTES (ISO_CODE_ESC, '['); \
3689 EMIT_ONE_BYTE (ISO_CODE_CSI); \
3693 #define ENCODE_DIRECTION_R2L() \
3695 ENCODE_CONTROL_SEQUENCE_INTRODUCER (dst); \
3696 EMIT_TWO_ASCII_BYTES ('2', ']'); \
3700 #define ENCODE_DIRECTION_L2R() \
3702 ENCODE_CONTROL_SEQUENCE_INTRODUCER (dst); \
3703 EMIT_TWO_ASCII_BYTES ('0', ']'); \
3707 /* Produce codes for designation and invocation to reset the graphic
3708 planes and registers to initial state. */
3709 #define ENCODE_RESET_PLANE_AND_REGISTER() \
3712 struct charset *charset; \
3714 if (CODING_ISO_INVOCATION (coding, 0) != 0) \
3716 for (reg = 0; reg < 4; reg++) \
3717 if (CODING_ISO_INITIAL (coding, reg) >= 0 \
3718 && (CODING_ISO_DESIGNATION (coding, reg) \
3719 != CODING_ISO_INITIAL (coding, reg))) \
3721 charset = CHARSET_FROM_ID (CODING_ISO_INITIAL (coding, reg)); \
3722 ENCODE_DESIGNATION (charset, reg, coding); \
3727 /* Produce designation sequences of charsets in the line started from
3728 SRC to a place pointed by DST, and return updated DST.
3730 If the current block ends before any end-of-line, we may fail to
3731 find all the necessary designations. */
3733 static unsigned char *
3734 encode_designation_at_bol (coding
, charbuf
, charbuf_end
, dst
)
3735 struct coding_system
*coding
;
3736 int *charbuf
, *charbuf_end
;
3739 struct charset
*charset
;
3740 /* Table of charsets to be designated to each graphic register. */
3742 int c
, found
= 0, reg
;
3743 int produced_chars
= 0;
3744 int multibytep
= coding
->dst_multibyte
;
3746 Lisp_Object charset_list
;
3748 attrs
= CODING_ID_ATTRS (coding
->id
);
3749 charset_list
= CODING_ATTR_CHARSET_LIST (attrs
);
3750 if (EQ (charset_list
, Qiso_2022
))
3751 charset_list
= Viso_2022_charset_list
;
3753 for (reg
= 0; reg
< 4; reg
++)
3763 charset
= char_charset (c
, charset_list
, NULL
);
3764 id
= CHARSET_ID (charset
);
3765 reg
= CODING_ISO_REQUEST (coding
, id
);
3766 if (reg
>= 0 && r
[reg
] < 0)
3775 for (reg
= 0; reg
< 4; reg
++)
3777 && CODING_ISO_DESIGNATION (coding
, reg
) != r
[reg
])
3778 ENCODE_DESIGNATION (CHARSET_FROM_ID (r
[reg
]), reg
, coding
);
3784 /* See the above "GENERAL NOTES on `encode_coding_XXX ()' functions". */
3787 encode_coding_iso_2022 (coding
)
3788 struct coding_system
*coding
;
3790 int multibytep
= coding
->dst_multibyte
;
3791 int *charbuf
= coding
->charbuf
;
3792 int *charbuf_end
= charbuf
+ coding
->charbuf_used
;
3793 unsigned char *dst
= coding
->destination
+ coding
->produced
;
3794 unsigned char *dst_end
= coding
->destination
+ coding
->dst_bytes
;
3797 = (CODING_ISO_FLAGS (coding
) & CODING_ISO_FLAG_DESIGNATE_AT_BOL
3798 && CODING_ISO_BOL (coding
));
3799 int produced_chars
= 0;
3800 Lisp_Object attrs
, eol_type
, charset_list
;
3801 int ascii_compatible
;
3803 int preferred_charset_id
= -1;
3805 CODING_GET_INFO (coding
, attrs
, charset_list
);
3806 eol_type
= CODING_ID_EOL_TYPE (coding
->id
);
3807 if (VECTORP (eol_type
))
3810 setup_iso_safe_charsets (attrs
);
3811 /* Charset list may have been changed. */
3812 charset_list
= CODING_ATTR_CHARSET_LIST (attrs
);
3813 coding
->safe_charsets
= (char *) SDATA (CODING_ATTR_SAFE_CHARSETS(attrs
));
3815 ascii_compatible
= ! NILP (CODING_ATTR_ASCII_COMPAT (attrs
));
3817 while (charbuf
< charbuf_end
)
3819 ASSURE_DESTINATION (safe_room
);
3821 if (bol_designation
)
3823 unsigned char *dst_prev
= dst
;
3825 /* We have to produce designation sequences if any now. */
3826 dst
= encode_designation_at_bol (coding
, charbuf
, charbuf_end
, dst
);
3827 bol_designation
= 0;
3828 /* We are sure that designation sequences are all ASCII bytes. */
3829 produced_chars
+= dst
- dst_prev
;
3836 /* Handle an annotation. */
3839 case CODING_ANNOTATE_COMPOSITION_MASK
:
3840 /* Not yet implemented. */
3842 case CODING_ANNOTATE_CHARSET_MASK
:
3843 preferred_charset_id
= charbuf
[2];
3844 if (preferred_charset_id
>= 0
3845 && NILP (Fmemq (make_number (preferred_charset_id
),
3847 preferred_charset_id
= -1;
3856 /* Now encode the character C. */
3857 if (c
< 0x20 || c
== 0x7F)
3860 || (c
== '\r' && EQ (eol_type
, Qmac
)))
3862 if (CODING_ISO_FLAGS (coding
) & CODING_ISO_FLAG_RESET_AT_EOL
)
3863 ENCODE_RESET_PLANE_AND_REGISTER ();
3864 if (CODING_ISO_FLAGS (coding
) & CODING_ISO_FLAG_INIT_AT_BOL
)
3868 for (i
= 0; i
< 4; i
++)
3869 CODING_ISO_DESIGNATION (coding
, i
)
3870 = CODING_ISO_INITIAL (coding
, i
);
3873 = CODING_ISO_FLAGS (coding
) & CODING_ISO_FLAG_DESIGNATE_AT_BOL
;
3875 else if (CODING_ISO_FLAGS (coding
) & CODING_ISO_FLAG_RESET_AT_CNTL
)
3876 ENCODE_RESET_PLANE_AND_REGISTER ();
3877 EMIT_ONE_ASCII_BYTE (c
);
3879 else if (ASCII_CHAR_P (c
))
3881 if (ascii_compatible
)
3882 EMIT_ONE_ASCII_BYTE (c
);
3885 struct charset
*charset
= CHARSET_FROM_ID (charset_ascii
);
3886 ENCODE_ISO_CHARACTER (charset
, c
);
3889 else if (CHAR_BYTE8_P (c
))
3891 c
= CHAR_TO_BYTE8 (c
);
3896 struct charset
*charset
;
3898 if (preferred_charset_id
>= 0)
3900 charset
= CHARSET_FROM_ID (preferred_charset_id
);
3901 if (! CHAR_CHARSET_P (c
, charset
))
3902 charset
= char_charset (c
, charset_list
, NULL
);
3905 charset
= char_charset (c
, charset_list
, NULL
);
3908 if (coding
->mode
& CODING_MODE_SAFE_ENCODING
)
3910 c
= CODING_INHIBIT_CHARACTER_SUBSTITUTION
;
3911 charset
= CHARSET_FROM_ID (charset_ascii
);
3915 c
= coding
->default_char
;
3916 charset
= char_charset (c
, charset_list
, NULL
);
3919 ENCODE_ISO_CHARACTER (charset
, c
);
3923 if (coding
->mode
& CODING_MODE_LAST_BLOCK
3924 && CODING_ISO_FLAGS (coding
) & CODING_ISO_FLAG_RESET_AT_EOL
)
3926 ASSURE_DESTINATION (safe_room
);
3927 ENCODE_RESET_PLANE_AND_REGISTER ();
3929 record_conversion_result (coding
, CODING_RESULT_SUCCESS
);
3930 CODING_ISO_BOL (coding
) = bol_designation
;
3931 coding
->produced_char
+= produced_chars
;
3932 coding
->produced
= dst
- coding
->destination
;
3937 /*** 8,9. SJIS and BIG5 handlers ***/
3939 /* Although SJIS and BIG5 are not ISO's coding system, they are used
3940 quite widely. So, for the moment, Emacs supports them in the bare
3941 C code. But, in the future, they may be supported only by CCL. */
3943 /* SJIS is a coding system encoding three character sets: ASCII, right
3944 half of JISX0201-Kana, and JISX0208. An ASCII character is encoded
3945 as is. A character of charset katakana-jisx0201 is encoded by
3946 "position-code + 0x80". A character of charset japanese-jisx0208
3947 is encoded in 2-byte but two position-codes are divided and shifted
3948 so that it fit in the range below.
3950 --- CODE RANGE of SJIS ---
3951 (character set) (range)
3953 KATAKANA-JISX0201 0xA0 .. 0xDF
3954 JISX0208 (1st byte) 0x81 .. 0x9F and 0xE0 .. 0xEF
3955 (2nd byte) 0x40 .. 0x7E and 0x80 .. 0xFC
3956 -------------------------------
3960 /* BIG5 is a coding system encoding two character sets: ASCII and
3961 Big5. An ASCII character is encoded as is. Big5 is a two-byte
3962 character set and is encoded in two-byte.
3964 --- CODE RANGE of BIG5 ---
3965 (character set) (range)
3967 Big5 (1st byte) 0xA1 .. 0xFE
3968 (2nd byte) 0x40 .. 0x7E and 0xA1 .. 0xFE
3969 --------------------------
3973 /* See the above "GENERAL NOTES on `detect_coding_XXX ()' functions".
3974 Check if a text is encoded in SJIS. If it is, return
3975 CATEGORY_MASK_SJIS, else return 0. */
3978 detect_coding_sjis (coding
, detect_info
)
3979 struct coding_system
*coding
;
3980 struct coding_detection_info
*detect_info
;
3982 const unsigned char *src
= coding
->source
, *src_base
;
3983 const unsigned char *src_end
= coding
->source
+ coding
->src_bytes
;
3984 int multibytep
= coding
->src_multibyte
;
3985 int consumed_chars
= 0;
3989 detect_info
->checked
|= CATEGORY_MASK_SJIS
;
3990 /* A coding system of this category is always ASCII compatible. */
3991 src
+= coding
->head_ascii
;
3999 if ((c
>= 0x81 && c
<= 0x9F) || (c
>= 0xE0 && c
<= 0xEF))
4002 if (c
< 0x40 || c
== 0x7F || c
> 0xFC)
4004 found
= CATEGORY_MASK_SJIS
;
4006 else if (c
>= 0xA0 && c
< 0xE0)
4007 found
= CATEGORY_MASK_SJIS
;
4011 detect_info
->rejected
|= CATEGORY_MASK_SJIS
;
4015 if (src_base
< src
&& coding
->mode
& CODING_MODE_LAST_BLOCK
)
4017 detect_info
->rejected
|= CATEGORY_MASK_SJIS
;
4020 detect_info
->found
|= found
;
4024 /* See the above "GENERAL NOTES on `detect_coding_XXX ()' functions".
4025 Check if a text is encoded in BIG5. If it is, return
4026 CATEGORY_MASK_BIG5, else return 0. */
4029 detect_coding_big5 (coding
, detect_info
)
4030 struct coding_system
*coding
;
4031 struct coding_detection_info
*detect_info
;
4033 const unsigned char *src
= coding
->source
, *src_base
;
4034 const unsigned char *src_end
= coding
->source
+ coding
->src_bytes
;
4035 int multibytep
= coding
->src_multibyte
;
4036 int consumed_chars
= 0;
4040 detect_info
->checked
|= CATEGORY_MASK_BIG5
;
4041 /* A coding system of this category is always ASCII compatible. */
4042 src
+= coding
->head_ascii
;
4053 if (c
< 0x40 || (c
>= 0x7F && c
<= 0xA0))
4055 found
= CATEGORY_MASK_BIG5
;
4060 detect_info
->rejected
|= CATEGORY_MASK_BIG5
;
4064 if (src_base
< src
&& coding
->mode
& CODING_MODE_LAST_BLOCK
)
4066 detect_info
->rejected
|= CATEGORY_MASK_BIG5
;
4069 detect_info
->found
|= found
;
4073 /* See the above "GENERAL NOTES on `decode_coding_XXX ()' functions".
4074 If SJIS_P is 1, decode SJIS text, else decode BIG5 test. */
4077 decode_coding_sjis (coding
)
4078 struct coding_system
*coding
;
4080 const unsigned char *src
= coding
->source
+ coding
->consumed
;
4081 const unsigned char *src_end
= coding
->source
+ coding
->src_bytes
;
4082 const unsigned char *src_base
;
4083 int *charbuf
= coding
->charbuf
+ coding
->charbuf_used
;
4085 = coding
->charbuf
+ coding
->charbuf_size
- MAX_ANNOTATION_LENGTH
;
4086 int consumed_chars
= 0, consumed_chars_base
;
4087 int multibytep
= coding
->src_multibyte
;
4088 struct charset
*charset_roman
, *charset_kanji
, *charset_kana
;
4089 struct charset
*charset_kanji2
;
4090 Lisp_Object attrs
, charset_list
, val
;
4091 int char_offset
= coding
->produced_char
;
4092 int last_offset
= char_offset
;
4093 int last_id
= charset_ascii
;
4095 CODING_GET_INFO (coding
, attrs
, charset_list
);
4098 charset_roman
= CHARSET_FROM_ID (XINT (XCAR (val
))), val
= XCDR (val
);
4099 charset_kana
= CHARSET_FROM_ID (XINT (XCAR (val
))), val
= XCDR (val
);
4100 charset_kanji
= CHARSET_FROM_ID (XINT (XCAR (val
))), val
= XCDR (val
);
4101 charset_kanji2
= NILP (val
) ? NULL
: CHARSET_FROM_ID (XINT (XCAR (val
)));
4106 struct charset
*charset
;
4109 consumed_chars_base
= consumed_chars
;
4111 if (charbuf
>= charbuf_end
)
4118 charset
= charset_roman
;
4119 else if (c
== 0x80 || c
== 0xA0)
4121 else if (c
>= 0xA1 && c
<= 0xDF)
4123 /* SJIS -> JISX0201-Kana */
4125 charset
= charset_kana
;
4129 /* SJIS -> JISX0208 */
4131 if (c1
< 0x40 || c1
== 0x7F || c1
> 0xFC)
4135 charset
= charset_kanji
;
4137 else if (c
<= 0xFC && charset_kanji2
)
4139 /* SJIS -> JISX0213-2 */
4141 if (c1
< 0x40 || c1
== 0x7F || c1
> 0xFC)
4145 charset
= charset_kanji2
;
4149 if (charset
->id
!= charset_ascii
4150 && last_id
!= charset
->id
)
4152 if (last_id
!= charset_ascii
)
4153 ADD_CHARSET_DATA (charbuf
, char_offset
- last_offset
, last_id
);
4154 last_id
= charset
->id
;
4155 last_offset
= char_offset
;
4157 CODING_DECODE_CHAR (coding
, src
, src_base
, src_end
, charset
, c
, c
);
4164 consumed_chars
= consumed_chars_base
;
4166 *charbuf
++ = c
< 0 ? -c
: BYTE8_TO_CHAR (c
);
4172 if (last_id
!= charset_ascii
)
4173 ADD_CHARSET_DATA (charbuf
, char_offset
- last_offset
, last_id
);
4174 coding
->consumed_char
+= consumed_chars_base
;
4175 coding
->consumed
= src_base
- coding
->source
;
4176 coding
->charbuf_used
= charbuf
- coding
->charbuf
;
4180 decode_coding_big5 (coding
)
4181 struct coding_system
*coding
;
4183 const unsigned char *src
= coding
->source
+ coding
->consumed
;
4184 const unsigned char *src_end
= coding
->source
+ coding
->src_bytes
;
4185 const unsigned char *src_base
;
4186 int *charbuf
= coding
->charbuf
+ coding
->charbuf_used
;
4188 = coding
->charbuf
+ coding
->charbuf_size
- MAX_ANNOTATION_LENGTH
;
4189 int consumed_chars
= 0, consumed_chars_base
;
4190 int multibytep
= coding
->src_multibyte
;
4191 struct charset
*charset_roman
, *charset_big5
;
4192 Lisp_Object attrs
, charset_list
, val
;
4193 int char_offset
= coding
->produced_char
;
4194 int last_offset
= char_offset
;
4195 int last_id
= charset_ascii
;
4197 CODING_GET_INFO (coding
, attrs
, charset_list
);
4199 charset_roman
= CHARSET_FROM_ID (XINT (XCAR (val
))), val
= XCDR (val
);
4200 charset_big5
= CHARSET_FROM_ID (XINT (XCAR (val
)));
4205 struct charset
*charset
;
4208 consumed_chars_base
= consumed_chars
;
4210 if (charbuf
>= charbuf_end
)
4218 charset
= charset_roman
;
4222 if (c
< 0xA1 || c
> 0xFE)
4225 if (c1
< 0x40 || (c1
> 0x7E && c1
< 0xA1) || c1
> 0xFE)
4228 charset
= charset_big5
;
4230 if (charset
->id
!= charset_ascii
4231 && last_id
!= charset
->id
)
4233 if (last_id
!= charset_ascii
)
4234 ADD_CHARSET_DATA (charbuf
, char_offset
- last_offset
, last_id
);
4235 last_id
= charset
->id
;
4236 last_offset
= char_offset
;
4238 CODING_DECODE_CHAR (coding
, src
, src_base
, src_end
, charset
, c
, c
);
4245 consumed_chars
= consumed_chars_base
;
4247 *charbuf
++ = c
< 0 ? -c
: BYTE8_TO_CHAR (c
);
4253 if (last_id
!= charset_ascii
)
4254 ADD_CHARSET_DATA (charbuf
, char_offset
- last_offset
, last_id
);
4255 coding
->consumed_char
+= consumed_chars_base
;
4256 coding
->consumed
= src_base
- coding
->source
;
4257 coding
->charbuf_used
= charbuf
- coding
->charbuf
;
4260 /* See the above "GENERAL NOTES on `encode_coding_XXX ()' functions".
4261 This function can encode charsets `ascii', `katakana-jisx0201',
4262 `japanese-jisx0208', `chinese-big5-1', and `chinese-big5-2'. We
4263 are sure that all these charsets are registered as official charset
4264 (i.e. do not have extended leading-codes). Characters of other
4265 charsets are produced without any encoding. If SJIS_P is 1, encode
4266 SJIS text, else encode BIG5 text. */
4269 encode_coding_sjis (coding
)
4270 struct coding_system
*coding
;
4272 int multibytep
= coding
->dst_multibyte
;
4273 int *charbuf
= coding
->charbuf
;
4274 int *charbuf_end
= charbuf
+ coding
->charbuf_used
;
4275 unsigned char *dst
= coding
->destination
+ coding
->produced
;
4276 unsigned char *dst_end
= coding
->destination
+ coding
->dst_bytes
;
4278 int produced_chars
= 0;
4279 Lisp_Object attrs
, charset_list
, val
;
4280 int ascii_compatible
;
4281 struct charset
*charset_roman
, *charset_kanji
, *charset_kana
;
4282 struct charset
*charset_kanji2
;
4285 CODING_GET_INFO (coding
, attrs
, charset_list
);
4287 charset_roman
= CHARSET_FROM_ID (XINT (XCAR (val
))), val
= XCDR (val
);
4288 charset_kana
= CHARSET_FROM_ID (XINT (XCAR (val
))), val
= XCDR (val
);
4289 charset_kanji
= CHARSET_FROM_ID (XINT (XCAR (val
))), val
= XCDR (val
);
4290 charset_kanji2
= NILP (val
) ? NULL
: CHARSET_FROM_ID (XINT (XCAR (val
)));
4292 ascii_compatible
= ! NILP (CODING_ATTR_ASCII_COMPAT (attrs
));
4294 while (charbuf
< charbuf_end
)
4296 ASSURE_DESTINATION (safe_room
);
4298 /* Now encode the character C. */
4299 if (ASCII_CHAR_P (c
) && ascii_compatible
)
4300 EMIT_ONE_ASCII_BYTE (c
);
4301 else if (CHAR_BYTE8_P (c
))
4303 c
= CHAR_TO_BYTE8 (c
);
4309 struct charset
*charset
= char_charset (c
, charset_list
, &code
);
4313 if (coding
->mode
& CODING_MODE_SAFE_ENCODING
)
4315 code
= CODING_INHIBIT_CHARACTER_SUBSTITUTION
;
4316 charset
= CHARSET_FROM_ID (charset_ascii
);
4320 c
= coding
->default_char
;
4321 charset
= char_charset (c
, charset_list
, &code
);
4324 if (code
== CHARSET_INVALID_CODE (charset
))
4326 if (charset
== charset_kanji
)
4330 c1
= code
>> 8, c2
= code
& 0xFF;
4331 EMIT_TWO_BYTES (c1
, c2
);
4333 else if (charset
== charset_kana
)
4334 EMIT_ONE_BYTE (code
| 0x80);
4335 else if (charset_kanji2
&& charset
== charset_kanji2
)
4340 if (c1
== 0x21 || (c1
>= 0x23 && c1
< 0x25)
4341 || (c1
>= 0x2C && c1
<= 0x2F) || c1
>= 0x6E)
4343 JIS_TO_SJIS2 (code
);
4344 c1
= code
>> 8, c2
= code
& 0xFF;
4345 EMIT_TWO_BYTES (c1
, c2
);
4348 EMIT_ONE_ASCII_BYTE (code
& 0x7F);
4351 EMIT_ONE_ASCII_BYTE (code
& 0x7F);
4354 record_conversion_result (coding
, CODING_RESULT_SUCCESS
);
4355 coding
->produced_char
+= produced_chars
;
4356 coding
->produced
= dst
- coding
->destination
;
4361 encode_coding_big5 (coding
)
4362 struct coding_system
*coding
;
4364 int multibytep
= coding
->dst_multibyte
;
4365 int *charbuf
= coding
->charbuf
;
4366 int *charbuf_end
= charbuf
+ coding
->charbuf_used
;
4367 unsigned char *dst
= coding
->destination
+ coding
->produced
;
4368 unsigned char *dst_end
= coding
->destination
+ coding
->dst_bytes
;
4370 int produced_chars
= 0;
4371 Lisp_Object attrs
, charset_list
, val
;
4372 int ascii_compatible
;
4373 struct charset
*charset_roman
, *charset_big5
;
4376 CODING_GET_INFO (coding
, attrs
, charset_list
);
4378 charset_roman
= CHARSET_FROM_ID (XINT (XCAR (val
))), val
= XCDR (val
);
4379 charset_big5
= CHARSET_FROM_ID (XINT (XCAR (val
)));
4380 ascii_compatible
= ! NILP (CODING_ATTR_ASCII_COMPAT (attrs
));
4382 while (charbuf
< charbuf_end
)
4384 ASSURE_DESTINATION (safe_room
);
4386 /* Now encode the character C. */
4387 if (ASCII_CHAR_P (c
) && ascii_compatible
)
4388 EMIT_ONE_ASCII_BYTE (c
);
4389 else if (CHAR_BYTE8_P (c
))
4391 c
= CHAR_TO_BYTE8 (c
);
4397 struct charset
*charset
= char_charset (c
, charset_list
, &code
);
4401 if (coding
->mode
& CODING_MODE_SAFE_ENCODING
)
4403 code
= CODING_INHIBIT_CHARACTER_SUBSTITUTION
;
4404 charset
= CHARSET_FROM_ID (charset_ascii
);
4408 c
= coding
->default_char
;
4409 charset
= char_charset (c
, charset_list
, &code
);
4412 if (code
== CHARSET_INVALID_CODE (charset
))
4414 if (charset
== charset_big5
)
4418 c1
= code
>> 8, c2
= code
& 0xFF;
4419 EMIT_TWO_BYTES (c1
, c2
);
4422 EMIT_ONE_ASCII_BYTE (code
& 0x7F);
4425 record_conversion_result (coding
, CODING_RESULT_SUCCESS
);
4426 coding
->produced_char
+= produced_chars
;
4427 coding
->produced
= dst
- coding
->destination
;
4432 /*** 10. CCL handlers ***/
4434 /* See the above "GENERAL NOTES on `detect_coding_XXX ()' functions".
4435 Check if a text is encoded in a coding system of which
4436 encoder/decoder are written in CCL program. If it is, return
4437 CATEGORY_MASK_CCL, else return 0. */
4440 detect_coding_ccl (coding
, detect_info
)
4441 struct coding_system
*coding
;
4442 struct coding_detection_info
*detect_info
;
4444 const unsigned char *src
= coding
->source
, *src_base
;
4445 const unsigned char *src_end
= coding
->source
+ coding
->src_bytes
;
4446 int multibytep
= coding
->src_multibyte
;
4447 int consumed_chars
= 0;
4449 unsigned char *valids
;
4450 int head_ascii
= coding
->head_ascii
;
4453 detect_info
->checked
|= CATEGORY_MASK_CCL
;
4455 coding
= &coding_categories
[coding_category_ccl
];
4456 valids
= CODING_CCL_VALIDS (coding
);
4457 attrs
= CODING_ID_ATTRS (coding
->id
);
4458 if (! NILP (CODING_ATTR_ASCII_COMPAT (attrs
)))
4467 if (c
< 0 || ! valids
[c
])
4469 if ((valids
[c
] > 1))
4470 found
= CATEGORY_MASK_CCL
;
4472 detect_info
->rejected
|= CATEGORY_MASK_CCL
;
4476 detect_info
->found
|= found
;
4481 decode_coding_ccl (coding
)
4482 struct coding_system
*coding
;
4484 const unsigned char *src
= coding
->source
+ coding
->consumed
;
4485 const unsigned char *src_end
= coding
->source
+ coding
->src_bytes
;
4486 int *charbuf
= coding
->charbuf
+ coding
->charbuf_used
;
4487 int *charbuf_end
= coding
->charbuf
+ coding
->charbuf_size
;
4488 int consumed_chars
= 0;
4489 int multibytep
= coding
->src_multibyte
;
4490 struct ccl_program ccl
;
4491 int source_charbuf
[1024];
4492 int source_byteidx
[1024];
4493 Lisp_Object attrs
, charset_list
;
4495 CODING_GET_INFO (coding
, attrs
, charset_list
);
4496 setup_ccl_program (&ccl
, CODING_CCL_DECODER (coding
));
4498 while (src
< src_end
)
4500 const unsigned char *p
= src
;
4501 int *source
, *source_end
;
4505 while (i
< 1024 && p
< src_end
)
4507 source_byteidx
[i
] = p
- src
;
4508 source_charbuf
[i
++] = STRING_CHAR_ADVANCE (p
);
4511 while (i
< 1024 && p
< src_end
)
4512 source_charbuf
[i
++] = *p
++;
4514 if (p
== src_end
&& coding
->mode
& CODING_MODE_LAST_BLOCK
)
4517 source
= source_charbuf
;
4518 source_end
= source
+ i
;
4519 while (source
< source_end
)
4521 ccl_driver (&ccl
, source
, charbuf
,
4522 source_end
- source
, charbuf_end
- charbuf
,
4524 source
+= ccl
.consumed
;
4525 charbuf
+= ccl
.produced
;
4526 if (ccl
.status
!= CCL_STAT_SUSPEND_BY_DST
)
4529 if (source
< source_end
)
4530 src
+= source_byteidx
[source
- source_charbuf
];
4533 consumed_chars
+= source
- source_charbuf
;
4535 if (ccl
.status
!= CCL_STAT_SUSPEND_BY_SRC
4536 && ccl
.status
!= CODING_RESULT_INSUFFICIENT_SRC
)
4542 case CCL_STAT_SUSPEND_BY_SRC
:
4543 record_conversion_result (coding
, CODING_RESULT_INSUFFICIENT_SRC
);
4545 case CCL_STAT_SUSPEND_BY_DST
:
4548 case CCL_STAT_INVALID_CMD
:
4549 record_conversion_result (coding
, CODING_RESULT_INTERRUPT
);
4552 record_conversion_result (coding
, CODING_RESULT_SUCCESS
);
4555 coding
->consumed_char
+= consumed_chars
;
4556 coding
->consumed
= src
- coding
->source
;
4557 coding
->charbuf_used
= charbuf
- coding
->charbuf
;
4561 encode_coding_ccl (coding
)
4562 struct coding_system
*coding
;
4564 struct ccl_program ccl
;
4565 int multibytep
= coding
->dst_multibyte
;
4566 int *charbuf
= coding
->charbuf
;
4567 int *charbuf_end
= charbuf
+ coding
->charbuf_used
;
4568 unsigned char *dst
= coding
->destination
+ coding
->produced
;
4569 unsigned char *dst_end
= coding
->destination
+ coding
->dst_bytes
;
4570 int destination_charbuf
[1024];
4571 int i
, produced_chars
= 0;
4572 Lisp_Object attrs
, charset_list
;
4574 CODING_GET_INFO (coding
, attrs
, charset_list
);
4575 setup_ccl_program (&ccl
, CODING_CCL_ENCODER (coding
));
4577 ccl
.last_block
= coding
->mode
& CODING_MODE_LAST_BLOCK
;
4578 ccl
.dst_multibyte
= coding
->dst_multibyte
;
4580 while (charbuf
< charbuf_end
)
4582 ccl_driver (&ccl
, charbuf
, destination_charbuf
,
4583 charbuf_end
- charbuf
, 1024, charset_list
);
4586 ASSURE_DESTINATION (ccl
.produced
* 2);
4587 for (i
= 0; i
< ccl
.produced
; i
++)
4588 EMIT_ONE_BYTE (destination_charbuf
[i
] & 0xFF);
4592 ASSURE_DESTINATION (ccl
.produced
);
4593 for (i
= 0; i
< ccl
.produced
; i
++)
4594 *dst
++ = destination_charbuf
[i
] & 0xFF;
4595 produced_chars
+= ccl
.produced
;
4597 charbuf
+= ccl
.consumed
;
4598 if (ccl
.status
== CCL_STAT_QUIT
4599 || ccl
.status
== CCL_STAT_INVALID_CMD
)
4605 case CCL_STAT_SUSPEND_BY_SRC
:
4606 record_conversion_result (coding
, CODING_RESULT_INSUFFICIENT_SRC
);
4608 case CCL_STAT_SUSPEND_BY_DST
:
4609 record_conversion_result (coding
, CODING_RESULT_INSUFFICIENT_DST
);
4612 case CCL_STAT_INVALID_CMD
:
4613 record_conversion_result (coding
, CODING_RESULT_INTERRUPT
);
4616 record_conversion_result (coding
, CODING_RESULT_SUCCESS
);
4620 coding
->produced_char
+= produced_chars
;
4621 coding
->produced
= dst
- coding
->destination
;
4627 /*** 10, 11. no-conversion handlers ***/
4629 /* See the above "GENERAL NOTES on `decode_coding_XXX ()' functions". */
4632 decode_coding_raw_text (coding
)
4633 struct coding_system
*coding
;
4635 coding
->chars_at_source
= 1;
4636 coding
->consumed_char
= 0;
4637 coding
->consumed
= 0;
4638 record_conversion_result (coding
, CODING_RESULT_SUCCESS
);
4642 encode_coding_raw_text (coding
)
4643 struct coding_system
*coding
;
4645 int multibytep
= coding
->dst_multibyte
;
4646 int *charbuf
= coding
->charbuf
;
4647 int *charbuf_end
= coding
->charbuf
+ coding
->charbuf_used
;
4648 unsigned char *dst
= coding
->destination
+ coding
->produced
;
4649 unsigned char *dst_end
= coding
->destination
+ coding
->dst_bytes
;
4650 int produced_chars
= 0;
4655 int safe_room
= MAX_MULTIBYTE_LENGTH
* 2;
4657 if (coding
->src_multibyte
)
4658 while (charbuf
< charbuf_end
)
4660 ASSURE_DESTINATION (safe_room
);
4662 if (ASCII_CHAR_P (c
))
4663 EMIT_ONE_ASCII_BYTE (c
);
4664 else if (CHAR_BYTE8_P (c
))
4666 c
= CHAR_TO_BYTE8 (c
);
4671 unsigned char str
[MAX_MULTIBYTE_LENGTH
], *p0
= str
, *p1
= str
;
4673 CHAR_STRING_ADVANCE (c
, p1
);
4676 EMIT_ONE_BYTE (*p0
);
4682 while (charbuf
< charbuf_end
)
4684 ASSURE_DESTINATION (safe_room
);
4691 if (coding
->src_multibyte
)
4693 int safe_room
= MAX_MULTIBYTE_LENGTH
;
4695 while (charbuf
< charbuf_end
)
4697 ASSURE_DESTINATION (safe_room
);
4699 if (ASCII_CHAR_P (c
))
4701 else if (CHAR_BYTE8_P (c
))
4702 *dst
++ = CHAR_TO_BYTE8 (c
);
4704 CHAR_STRING_ADVANCE (c
, dst
);
4710 ASSURE_DESTINATION (charbuf_end
- charbuf
);
4711 while (charbuf
< charbuf_end
&& dst
< dst_end
)
4712 *dst
++ = *charbuf
++;
4713 produced_chars
= dst
- (coding
->destination
+ coding
->dst_bytes
);
4716 record_conversion_result (coding
, CODING_RESULT_SUCCESS
);
4717 coding
->produced_char
+= produced_chars
;
4718 coding
->produced
= dst
- coding
->destination
;
4722 /* See the above "GENERAL NOTES on `detect_coding_XXX ()' functions".
4723 Check if a text is encoded in a charset-based coding system. If it
4724 is, return 1, else return 0. */
4727 detect_coding_charset (coding
, detect_info
)
4728 struct coding_system
*coding
;
4729 struct coding_detection_info
*detect_info
;
4731 const unsigned char *src
= coding
->source
, *src_base
;
4732 const unsigned char *src_end
= coding
->source
+ coding
->src_bytes
;
4733 int multibytep
= coding
->src_multibyte
;
4734 int consumed_chars
= 0;
4735 Lisp_Object attrs
, valids
;
4737 int head_ascii
= coding
->head_ascii
;
4739 detect_info
->checked
|= CATEGORY_MASK_CHARSET
;
4741 coding
= &coding_categories
[coding_category_charset
];
4742 attrs
= CODING_ID_ATTRS (coding
->id
);
4743 valids
= AREF (attrs
, coding_attr_charset_valids
);
4745 if (! NILP (CODING_ATTR_ASCII_COMPAT (attrs
)))
4752 struct charset
*charset
;
4759 val
= AREF (valids
, c
);
4763 found
= CATEGORY_MASK_CHARSET
;
4766 charset
= CHARSET_FROM_ID (XFASTINT (val
));
4767 dim
= CHARSET_DIMENSION (charset
);
4768 for (idx
= 1; idx
< dim
; idx
++)
4773 if (c
< charset
->code_space
[(dim
- 1 - idx
) * 2]
4774 || c
> charset
->code_space
[(dim
- 1 - idx
) * 2 + 1])
4783 for (; CONSP (val
); val
= XCDR (val
))
4785 charset
= CHARSET_FROM_ID (XFASTINT (XCAR (val
)));
4786 dim
= CHARSET_DIMENSION (charset
);
4792 if (c
< charset
->code_space
[(dim
- 1 - idx
) * 4]
4793 || c
> charset
->code_space
[(dim
- 1 - idx
) * 4 + 1])
4808 detect_info
->rejected
|= CATEGORY_MASK_CHARSET
;
4812 detect_info
->found
|= found
;
4817 decode_coding_charset (coding
)
4818 struct coding_system
*coding
;
4820 const unsigned char *src
= coding
->source
+ coding
->consumed
;
4821 const unsigned char *src_end
= coding
->source
+ coding
->src_bytes
;
4822 const unsigned char *src_base
;
4823 int *charbuf
= coding
->charbuf
+ coding
->charbuf_used
;
4825 = coding
->charbuf
+ coding
->charbuf_size
- MAX_ANNOTATION_LENGTH
;
4826 int consumed_chars
= 0, consumed_chars_base
;
4827 int multibytep
= coding
->src_multibyte
;
4828 Lisp_Object attrs
, charset_list
, valids
;
4829 int char_offset
= coding
->produced_char
;
4830 int last_offset
= char_offset
;
4831 int last_id
= charset_ascii
;
4833 CODING_GET_INFO (coding
, attrs
, charset_list
);
4834 valids
= AREF (attrs
, coding_attr_charset_valids
);
4840 struct charset
*charset
;
4846 consumed_chars_base
= consumed_chars
;
4848 if (charbuf
>= charbuf_end
)
4856 val
= AREF (valids
, c
);
4861 charset
= CHARSET_FROM_ID (XFASTINT (val
));
4862 dim
= CHARSET_DIMENSION (charset
);
4866 code
= (code
<< 8) | c
;
4869 CODING_DECODE_CHAR (coding
, src
, src_base
, src_end
,
4874 /* VAL is a list of charset IDs. It is assured that the
4875 list is sorted by charset dimensions (smaller one
4879 charset
= CHARSET_FROM_ID (XFASTINT (XCAR (val
)));
4880 dim
= CHARSET_DIMENSION (charset
);
4884 code
= (code
<< 8) | c
;
4887 CODING_DECODE_CHAR (coding
, src
, src_base
,
4888 src_end
, charset
, code
, c
);
4896 if (charset
->id
!= charset_ascii
4897 && last_id
!= charset
->id
)
4899 if (last_id
!= charset_ascii
)
4900 ADD_CHARSET_DATA (charbuf
, char_offset
- last_offset
, last_id
);
4901 last_id
= charset
->id
;
4902 last_offset
= char_offset
;
4911 consumed_chars
= consumed_chars_base
;
4913 *charbuf
++ = c
< 0 ? -c
: ASCII_BYTE_P (c
) ? c
: BYTE8_TO_CHAR (c
);
4919 if (last_id
!= charset_ascii
)
4920 ADD_CHARSET_DATA (charbuf
, char_offset
- last_offset
, last_id
);
4921 coding
->consumed_char
+= consumed_chars_base
;
4922 coding
->consumed
= src_base
- coding
->source
;
4923 coding
->charbuf_used
= charbuf
- coding
->charbuf
;
4927 encode_coding_charset (coding
)
4928 struct coding_system
*coding
;
4930 int multibytep
= coding
->dst_multibyte
;
4931 int *charbuf
= coding
->charbuf
;
4932 int *charbuf_end
= charbuf
+ coding
->charbuf_used
;
4933 unsigned char *dst
= coding
->destination
+ coding
->produced
;
4934 unsigned char *dst_end
= coding
->destination
+ coding
->dst_bytes
;
4935 int safe_room
= MAX_MULTIBYTE_LENGTH
;
4936 int produced_chars
= 0;
4937 Lisp_Object attrs
, charset_list
;
4938 int ascii_compatible
;
4941 CODING_GET_INFO (coding
, attrs
, charset_list
);
4942 ascii_compatible
= ! NILP (CODING_ATTR_ASCII_COMPAT (attrs
));
4944 while (charbuf
< charbuf_end
)
4946 struct charset
*charset
;
4949 ASSURE_DESTINATION (safe_room
);
4951 if (ascii_compatible
&& ASCII_CHAR_P (c
))
4952 EMIT_ONE_ASCII_BYTE (c
);
4953 else if (CHAR_BYTE8_P (c
))
4955 c
= CHAR_TO_BYTE8 (c
);
4960 charset
= char_charset (c
, charset_list
, &code
);
4963 if (CHARSET_DIMENSION (charset
) == 1)
4964 EMIT_ONE_BYTE (code
);
4965 else if (CHARSET_DIMENSION (charset
) == 2)
4966 EMIT_TWO_BYTES (code
>> 8, code
& 0xFF);
4967 else if (CHARSET_DIMENSION (charset
) == 3)
4968 EMIT_THREE_BYTES (code
>> 16, (code
>> 8) & 0xFF, code
& 0xFF);
4970 EMIT_FOUR_BYTES (code
>> 24, (code
>> 16) & 0xFF,
4971 (code
>> 8) & 0xFF, code
& 0xFF);
4975 if (coding
->mode
& CODING_MODE_SAFE_ENCODING
)
4976 c
= CODING_INHIBIT_CHARACTER_SUBSTITUTION
;
4978 c
= coding
->default_char
;
4984 record_conversion_result (coding
, CODING_RESULT_SUCCESS
);
4985 coding
->produced_char
+= produced_chars
;
4986 coding
->produced
= dst
- coding
->destination
;
4991 /*** 7. C library functions ***/
4993 /* Setup coding context CODING from information about CODING_SYSTEM.
4994 If CODING_SYSTEM is nil, `no-conversion' is assumed. If
4995 CODING_SYSTEM is invalid, signal an error. */
4998 setup_coding_system (coding_system
, coding
)
4999 Lisp_Object coding_system
;
5000 struct coding_system
*coding
;
5003 Lisp_Object eol_type
;
5004 Lisp_Object coding_type
;
5007 if (NILP (coding_system
))
5008 coding_system
= Qundecided
;
5010 CHECK_CODING_SYSTEM_GET_ID (coding_system
, coding
->id
);
5012 attrs
= CODING_ID_ATTRS (coding
->id
);
5013 eol_type
= CODING_ID_EOL_TYPE (coding
->id
);
5016 coding
->head_ascii
= -1;
5017 if (VECTORP (eol_type
))
5018 coding
->common_flags
= (CODING_REQUIRE_DECODING_MASK
5019 | CODING_REQUIRE_DETECTION_MASK
);
5020 else if (! EQ (eol_type
, Qunix
))
5021 coding
->common_flags
= (CODING_REQUIRE_DECODING_MASK
5022 | CODING_REQUIRE_ENCODING_MASK
);
5024 coding
->common_flags
= 0;
5025 if (! NILP (CODING_ATTR_POST_READ (attrs
)))
5026 coding
->common_flags
|= CODING_REQUIRE_DECODING_MASK
;
5027 if (! NILP (CODING_ATTR_PRE_WRITE (attrs
)))
5028 coding
->common_flags
|= CODING_REQUIRE_ENCODING_MASK
;
5029 if (! NILP (CODING_ATTR_FOR_UNIBYTE (attrs
)))
5030 coding
->common_flags
|= CODING_FOR_UNIBYTE_MASK
;
5032 val
= CODING_ATTR_SAFE_CHARSETS (attrs
);
5033 coding
->max_charset_id
= SCHARS (val
) - 1;
5034 coding
->safe_charsets
= (char *) SDATA (val
);
5035 coding
->default_char
= XINT (CODING_ATTR_DEFAULT_CHAR (attrs
));
5037 coding_type
= CODING_ATTR_TYPE (attrs
);
5038 if (EQ (coding_type
, Qundecided
))
5040 coding
->detector
= NULL
;
5041 coding
->decoder
= decode_coding_raw_text
;
5042 coding
->encoder
= encode_coding_raw_text
;
5043 coding
->common_flags
|= CODING_REQUIRE_DETECTION_MASK
;
5045 else if (EQ (coding_type
, Qiso_2022
))
5048 int flags
= XINT (AREF (attrs
, coding_attr_iso_flags
));
5050 /* Invoke graphic register 0 to plane 0. */
5051 CODING_ISO_INVOCATION (coding
, 0) = 0;
5052 /* Invoke graphic register 1 to plane 1 if we can use 8-bit. */
5053 CODING_ISO_INVOCATION (coding
, 1)
5054 = (flags
& CODING_ISO_FLAG_SEVEN_BITS
? -1 : 1);
5055 /* Setup the initial status of designation. */
5056 for (i
= 0; i
< 4; i
++)
5057 CODING_ISO_DESIGNATION (coding
, i
) = CODING_ISO_INITIAL (coding
, i
);
5058 /* Not single shifting initially. */
5059 CODING_ISO_SINGLE_SHIFTING (coding
) = 0;
5060 /* Beginning of buffer should also be regarded as bol. */
5061 CODING_ISO_BOL (coding
) = 1;
5062 coding
->detector
= detect_coding_iso_2022
;
5063 coding
->decoder
= decode_coding_iso_2022
;
5064 coding
->encoder
= encode_coding_iso_2022
;
5065 if (flags
& CODING_ISO_FLAG_SAFE
)
5066 coding
->mode
|= CODING_MODE_SAFE_ENCODING
;
5067 coding
->common_flags
5068 |= (CODING_REQUIRE_DECODING_MASK
| CODING_REQUIRE_ENCODING_MASK
5069 | CODING_REQUIRE_FLUSHING_MASK
);
5070 if (flags
& CODING_ISO_FLAG_COMPOSITION
)
5071 coding
->common_flags
|= CODING_ANNOTATE_COMPOSITION_MASK
;
5072 if (flags
& CODING_ISO_FLAG_DESIGNATION
)
5073 coding
->common_flags
|= CODING_ANNOTATE_CHARSET_MASK
;
5074 if (flags
& CODING_ISO_FLAG_FULL_SUPPORT
)
5076 setup_iso_safe_charsets (attrs
);
5077 val
= CODING_ATTR_SAFE_CHARSETS (attrs
);
5078 coding
->max_charset_id
= SCHARS (val
) - 1;
5079 coding
->safe_charsets
= (char *) SDATA (val
);
5081 CODING_ISO_FLAGS (coding
) = flags
;
5083 else if (EQ (coding_type
, Qcharset
))
5085 coding
->detector
= detect_coding_charset
;
5086 coding
->decoder
= decode_coding_charset
;
5087 coding
->encoder
= encode_coding_charset
;
5088 coding
->common_flags
5089 |= (CODING_REQUIRE_DECODING_MASK
| CODING_REQUIRE_ENCODING_MASK
);
5091 else if (EQ (coding_type
, Qutf_8
))
5093 coding
->detector
= detect_coding_utf_8
;
5094 coding
->decoder
= decode_coding_utf_8
;
5095 coding
->encoder
= encode_coding_utf_8
;
5096 coding
->common_flags
5097 |= (CODING_REQUIRE_DECODING_MASK
| CODING_REQUIRE_ENCODING_MASK
);
5099 else if (EQ (coding_type
, Qutf_16
))
5101 val
= AREF (attrs
, coding_attr_utf_16_bom
);
5102 CODING_UTF_16_BOM (coding
) = (CONSP (val
) ? utf_16_detect_bom
5103 : EQ (val
, Qt
) ? utf_16_with_bom
5104 : utf_16_without_bom
);
5105 val
= AREF (attrs
, coding_attr_utf_16_endian
);
5106 CODING_UTF_16_ENDIAN (coding
) = (EQ (val
, Qbig
) ? utf_16_big_endian
5107 : utf_16_little_endian
);
5108 CODING_UTF_16_SURROGATE (coding
) = 0;
5109 coding
->detector
= detect_coding_utf_16
;
5110 coding
->decoder
= decode_coding_utf_16
;
5111 coding
->encoder
= encode_coding_utf_16
;
5112 coding
->common_flags
5113 |= (CODING_REQUIRE_DECODING_MASK
| CODING_REQUIRE_ENCODING_MASK
);
5114 if (CODING_UTF_16_BOM (coding
) == utf_16_detect_bom
)
5115 coding
->common_flags
|= CODING_REQUIRE_DETECTION_MASK
;
5117 else if (EQ (coding_type
, Qccl
))
5119 coding
->detector
= detect_coding_ccl
;
5120 coding
->decoder
= decode_coding_ccl
;
5121 coding
->encoder
= encode_coding_ccl
;
5122 coding
->common_flags
5123 |= (CODING_REQUIRE_DECODING_MASK
| CODING_REQUIRE_ENCODING_MASK
5124 | CODING_REQUIRE_FLUSHING_MASK
);
5126 else if (EQ (coding_type
, Qemacs_mule
))
5128 coding
->detector
= detect_coding_emacs_mule
;
5129 coding
->decoder
= decode_coding_emacs_mule
;
5130 coding
->encoder
= encode_coding_emacs_mule
;
5131 coding
->common_flags
5132 |= (CODING_REQUIRE_DECODING_MASK
| CODING_REQUIRE_ENCODING_MASK
);
5133 if (! NILP (AREF (attrs
, coding_attr_emacs_mule_full
))
5134 && ! EQ (CODING_ATTR_CHARSET_LIST (attrs
), Vemacs_mule_charset_list
))
5136 Lisp_Object tail
, safe_charsets
;
5137 int max_charset_id
= 0;
5139 for (tail
= Vemacs_mule_charset_list
; CONSP (tail
);
5141 if (max_charset_id
< XFASTINT (XCAR (tail
)))
5142 max_charset_id
= XFASTINT (XCAR (tail
));
5143 safe_charsets
= Fmake_string (make_number (max_charset_id
+ 1),
5145 for (tail
= Vemacs_mule_charset_list
; CONSP (tail
);
5147 SSET (safe_charsets
, XFASTINT (XCAR (tail
)), 0);
5148 coding
->max_charset_id
= max_charset_id
;
5149 coding
->safe_charsets
= (char *) SDATA (safe_charsets
);
5152 else if (EQ (coding_type
, Qshift_jis
))
5154 coding
->detector
= detect_coding_sjis
;
5155 coding
->decoder
= decode_coding_sjis
;
5156 coding
->encoder
= encode_coding_sjis
;
5157 coding
->common_flags
5158 |= (CODING_REQUIRE_DECODING_MASK
| CODING_REQUIRE_ENCODING_MASK
);
5160 else if (EQ (coding_type
, Qbig5
))
5162 coding
->detector
= detect_coding_big5
;
5163 coding
->decoder
= decode_coding_big5
;
5164 coding
->encoder
= encode_coding_big5
;
5165 coding
->common_flags
5166 |= (CODING_REQUIRE_DECODING_MASK
| CODING_REQUIRE_ENCODING_MASK
);
5168 else /* EQ (coding_type, Qraw_text) */
5170 coding
->detector
= NULL
;
5171 coding
->decoder
= decode_coding_raw_text
;
5172 coding
->encoder
= encode_coding_raw_text
;
5173 if (! EQ (eol_type
, Qunix
))
5175 coding
->common_flags
|= CODING_REQUIRE_DECODING_MASK
;
5176 if (! VECTORP (eol_type
))
5177 coding
->common_flags
|= CODING_REQUIRE_ENCODING_MASK
;
5185 /* Return a list of charsets supported by CODING. */
5188 coding_charset_list (coding
)
5189 struct coding_system
*coding
;
5191 Lisp_Object attrs
, charset_list
;
5193 CODING_GET_INFO (coding
, attrs
, charset_list
);
5194 if (EQ (CODING_ATTR_TYPE (attrs
), Qiso_2022
))
5196 int flags
= XINT (AREF (attrs
, coding_attr_iso_flags
));
5198 if (flags
& CODING_ISO_FLAG_FULL_SUPPORT
)
5199 charset_list
= Viso_2022_charset_list
;
5201 else if (EQ (CODING_ATTR_TYPE (attrs
), Qemacs_mule
))
5203 charset_list
= Vemacs_mule_charset_list
;
5205 return charset_list
;
5209 /* Return raw-text or one of its subsidiaries that has the same
5210 eol_type as CODING-SYSTEM. */
5213 raw_text_coding_system (coding_system
)
5214 Lisp_Object coding_system
;
5216 Lisp_Object spec
, attrs
;
5217 Lisp_Object eol_type
, raw_text_eol_type
;
5219 if (NILP (coding_system
))
5221 spec
= CODING_SYSTEM_SPEC (coding_system
);
5222 attrs
= AREF (spec
, 0);
5224 if (EQ (CODING_ATTR_TYPE (attrs
), Qraw_text
))
5225 return coding_system
;
5227 eol_type
= AREF (spec
, 2);
5228 if (VECTORP (eol_type
))
5230 spec
= CODING_SYSTEM_SPEC (Qraw_text
);
5231 raw_text_eol_type
= AREF (spec
, 2);
5232 return (EQ (eol_type
, Qunix
) ? AREF (raw_text_eol_type
, 0)
5233 : EQ (eol_type
, Qdos
) ? AREF (raw_text_eol_type
, 1)
5234 : AREF (raw_text_eol_type
, 2));
5238 /* If CODING_SYSTEM doesn't specify end-of-line format but PARENT
5239 does, return one of the subsidiary that has the same eol-spec as
5240 PARENT. Otherwise, return CODING_SYSTEM. If PARENT is nil,
5241 inherit end-of-line format from the system's setting
5242 (system_eol_type). */
5245 coding_inherit_eol_type (coding_system
, parent
)
5246 Lisp_Object coding_system
, parent
;
5248 Lisp_Object spec
, eol_type
;
5250 if (NILP (coding_system
))
5251 coding_system
= Qraw_text
;
5252 spec
= CODING_SYSTEM_SPEC (coding_system
);
5253 eol_type
= AREF (spec
, 2);
5254 if (VECTORP (eol_type
))
5256 Lisp_Object parent_eol_type
;
5258 if (! NILP (parent
))
5260 Lisp_Object parent_spec
;
5262 parent_spec
= CODING_SYSTEM_SPEC (parent
);
5263 parent_eol_type
= AREF (parent_spec
, 2);
5266 parent_eol_type
= system_eol_type
;
5267 if (EQ (parent_eol_type
, Qunix
))
5268 coding_system
= AREF (eol_type
, 0);
5269 else if (EQ (parent_eol_type
, Qdos
))
5270 coding_system
= AREF (eol_type
, 1);
5271 else if (EQ (parent_eol_type
, Qmac
))
5272 coding_system
= AREF (eol_type
, 2);
5274 return coding_system
;
5277 /* Emacs has a mechanism to automatically detect a coding system if it
5278 is one of Emacs' internal format, ISO2022, SJIS, and BIG5. But,
5279 it's impossible to distinguish some coding systems accurately
5280 because they use the same range of codes. So, at first, coding
5281 systems are categorized into 7, those are:
5283 o coding-category-emacs-mule
5285 The category for a coding system which has the same code range
5286 as Emacs' internal format. Assigned the coding-system (Lisp
5287 symbol) `emacs-mule' by default.
5289 o coding-category-sjis
5291 The category for a coding system which has the same code range
5292 as SJIS. Assigned the coding-system (Lisp
5293 symbol) `japanese-shift-jis' by default.
5295 o coding-category-iso-7
5297 The category for a coding system which has the same code range
5298 as ISO2022 of 7-bit environment. This doesn't use any locking
5299 shift and single shift functions. This can encode/decode all
5300 charsets. Assigned the coding-system (Lisp symbol)
5301 `iso-2022-7bit' by default.
5303 o coding-category-iso-7-tight
5305 Same as coding-category-iso-7 except that this can
5306 encode/decode only the specified charsets.
5308 o coding-category-iso-8-1
5310 The category for a coding system which has the same code range
5311 as ISO2022 of 8-bit environment and graphic plane 1 used only
5312 for DIMENSION1 charset. This doesn't use any locking shift
5313 and single shift functions. Assigned the coding-system (Lisp
5314 symbol) `iso-latin-1' by default.
5316 o coding-category-iso-8-2
5318 The category for a coding system which has the same code range
5319 as ISO2022 of 8-bit environment and graphic plane 1 used only
5320 for DIMENSION2 charset. This doesn't use any locking shift
5321 and single shift functions. Assigned the coding-system (Lisp
5322 symbol) `japanese-iso-8bit' by default.
5324 o coding-category-iso-7-else
5326 The category for a coding system which has the same code range
5327 as ISO2022 of 7-bit environemnt but uses locking shift or
5328 single shift functions. Assigned the coding-system (Lisp
5329 symbol) `iso-2022-7bit-lock' by default.
5331 o coding-category-iso-8-else
5333 The category for a coding system which has the same code range
5334 as ISO2022 of 8-bit environemnt but uses locking shift or
5335 single shift functions. Assigned the coding-system (Lisp
5336 symbol) `iso-2022-8bit-ss2' by default.
5338 o coding-category-big5
5340 The category for a coding system which has the same code range
5341 as BIG5. Assigned the coding-system (Lisp symbol)
5342 `cn-big5' by default.
5344 o coding-category-utf-8
5346 The category for a coding system which has the same code range
5347 as UTF-8 (cf. RFC3629). Assigned the coding-system (Lisp
5348 symbol) `utf-8' by default.
5350 o coding-category-utf-16-be
5352 The category for a coding system in which a text has an
5353 Unicode signature (cf. Unicode Standard) in the order of BIG
5354 endian at the head. Assigned the coding-system (Lisp symbol)
5355 `utf-16-be' by default.
5357 o coding-category-utf-16-le
5359 The category for a coding system in which a text has an
5360 Unicode signature (cf. Unicode Standard) in the order of
5361 LITTLE endian at the head. Assigned the coding-system (Lisp
5362 symbol) `utf-16-le' by default.
5364 o coding-category-ccl
5366 The category for a coding system of which encoder/decoder is
5367 written in CCL programs. The default value is nil, i.e., no
5368 coding system is assigned.
5370 o coding-category-binary
5372 The category for a coding system not categorized in any of the
5373 above. Assigned the coding-system (Lisp symbol)
5374 `no-conversion' by default.
5376 Each of them is a Lisp symbol and the value is an actual
5377 `coding-system's (this is also a Lisp symbol) assigned by a user.
5378 What Emacs does actually is to detect a category of coding system.
5379 Then, it uses a `coding-system' assigned to it. If Emacs can't
5380 decide only one possible category, it selects a category of the
5381 highest priority. Priorities of categories are also specified by a
5382 user in a Lisp variable `coding-category-list'.
5386 #define EOL_SEEN_NONE 0
5387 #define EOL_SEEN_LF 1
5388 #define EOL_SEEN_CR 2
5389 #define EOL_SEEN_CRLF 4
5391 /* Detect how end-of-line of a text of length SRC_BYTES pointed by
5392 SOURCE is encoded. If CATEGORY is one of
5393 coding_category_utf_16_XXXX, assume that CR and LF are encoded by
5394 two-byte, else they are encoded by one-byte.
5396 Return one of EOL_SEEN_XXX. */
5398 #define MAX_EOL_CHECK_COUNT 3
5401 detect_eol (source
, src_bytes
, category
)
5402 const unsigned char *source
;
5403 EMACS_INT src_bytes
;
5404 enum coding_category category
;
5406 const unsigned char *src
= source
, *src_end
= src
+ src_bytes
;
5409 int eol_seen
= EOL_SEEN_NONE
;
5411 if ((1 << category
) & CATEGORY_MASK_UTF_16
)
5415 msb
= category
== (coding_category_utf_16_le
5416 | coding_category_utf_16_le_nosig
);
5419 while (src
+ 1 < src_end
)
5422 if (src
[msb
] == 0 && (c
== '\n' || c
== '\r'))
5427 this_eol
= EOL_SEEN_LF
;
5428 else if (src
+ 3 >= src_end
5429 || src
[msb
+ 2] != 0
5430 || src
[lsb
+ 2] != '\n')
5431 this_eol
= EOL_SEEN_CR
;
5433 this_eol
= EOL_SEEN_CRLF
;
5435 if (eol_seen
== EOL_SEEN_NONE
)
5436 /* This is the first end-of-line. */
5437 eol_seen
= this_eol
;
5438 else if (eol_seen
!= this_eol
)
5440 /* The found type is different from what found before. */
5441 eol_seen
= EOL_SEEN_LF
;
5444 if (++total
== MAX_EOL_CHECK_COUNT
)
5452 while (src
< src_end
)
5455 if (c
== '\n' || c
== '\r')
5460 this_eol
= EOL_SEEN_LF
;
5461 else if (src
>= src_end
|| *src
!= '\n')
5462 this_eol
= EOL_SEEN_CR
;
5464 this_eol
= EOL_SEEN_CRLF
, src
++;
5466 if (eol_seen
== EOL_SEEN_NONE
)
5467 /* This is the first end-of-line. */
5468 eol_seen
= this_eol
;
5469 else if (eol_seen
!= this_eol
)
5471 /* The found type is different from what found before. */
5472 eol_seen
= EOL_SEEN_LF
;
5475 if (++total
== MAX_EOL_CHECK_COUNT
)
5485 adjust_coding_eol_type (coding
, eol_seen
)
5486 struct coding_system
*coding
;
5489 Lisp_Object eol_type
;
5491 eol_type
= CODING_ID_EOL_TYPE (coding
->id
);
5492 if (eol_seen
& EOL_SEEN_LF
)
5494 coding
->id
= CODING_SYSTEM_ID (AREF (eol_type
, 0));
5497 else if (eol_seen
& EOL_SEEN_CRLF
)
5499 coding
->id
= CODING_SYSTEM_ID (AREF (eol_type
, 1));
5502 else if (eol_seen
& EOL_SEEN_CR
)
5504 coding
->id
= CODING_SYSTEM_ID (AREF (eol_type
, 2));
5510 /* Detect how a text specified in CODING is encoded. If a coding
5511 system is detected, update fields of CODING by the detected coding
5515 detect_coding (coding
)
5516 struct coding_system
*coding
;
5518 const unsigned char *src
, *src_end
;
5520 coding
->consumed
= coding
->consumed_char
= 0;
5521 coding
->produced
= coding
->produced_char
= 0;
5522 coding_set_source (coding
);
5524 src_end
= coding
->source
+ coding
->src_bytes
;
5526 /* If we have not yet decided the text encoding type, detect it
5528 if (EQ (CODING_ATTR_TYPE (CODING_ID_ATTRS (coding
->id
)), Qundecided
))
5531 struct coding_detection_info detect_info
;
5533 detect_info
.checked
= detect_info
.found
= detect_info
.rejected
= 0;
5534 for (i
= 0, src
= coding
->source
; src
< src_end
; i
++, src
++)
5540 && (c
== ISO_CODE_ESC
|| c
== ISO_CODE_SI
|| c
== ISO_CODE_SO
)
5541 && ! inhibit_iso_escape_detection
5542 && ! detect_info
.checked
)
5544 coding
->head_ascii
= src
- (coding
->source
+ coding
->consumed
);
5545 if (detect_coding_iso_2022 (coding
, &detect_info
))
5547 /* We have scanned the whole data. */
5548 if (! (detect_info
.rejected
& CATEGORY_MASK_ISO_7_ELSE
))
5549 /* We didn't find an 8-bit code. */
5555 coding
->head_ascii
= src
- (coding
->source
+ coding
->consumed
);
5557 if (coding
->head_ascii
< coding
->src_bytes
5558 || detect_info
.found
)
5560 enum coding_category category
;
5561 struct coding_system
*this;
5563 if (coding
->head_ascii
== coding
->src_bytes
)
5564 /* As all bytes are 7-bit, we can ignore non-ISO-2022 codings. */
5565 for (i
= 0; i
< coding_category_raw_text
; i
++)
5567 category
= coding_priorities
[i
];
5568 this = coding_categories
+ category
;
5569 if (detect_info
.found
& (1 << category
))
5573 for (i
= 0; i
< coding_category_raw_text
; i
++)
5575 category
= coding_priorities
[i
];
5576 this = coding_categories
+ category
;
5579 /* No coding system of this category is defined. */
5580 detect_info
.rejected
|= (1 << category
);
5582 else if (category
>= coding_category_raw_text
)
5584 else if (detect_info
.checked
& (1 << category
))
5586 if (detect_info
.found
& (1 << category
))
5589 else if ((*(this->detector
)) (coding
, &detect_info
)
5590 && detect_info
.found
& (1 << category
))
5592 if (category
== coding_category_utf_16_auto
)
5594 if (detect_info
.found
& CATEGORY_MASK_UTF_16_LE
)
5595 category
= coding_category_utf_16_le
;
5597 category
= coding_category_utf_16_be
;
5603 if (i
< coding_category_raw_text
)
5604 setup_coding_system (CODING_ID_NAME (this->id
), coding
);
5605 else if (detect_info
.rejected
== CATEGORY_MASK_ANY
)
5606 setup_coding_system (Qraw_text
, coding
);
5607 else if (detect_info
.rejected
)
5608 for (i
= 0; i
< coding_category_raw_text
; i
++)
5609 if (! (detect_info
.rejected
& (1 << coding_priorities
[i
])))
5611 this = coding_categories
+ coding_priorities
[i
];
5612 setup_coding_system (CODING_ID_NAME (this->id
), coding
);
5617 else if (XINT (CODING_ATTR_CATEGORY (CODING_ID_ATTRS (coding
->id
)))
5618 == coding_category_utf_16_auto
)
5620 Lisp_Object coding_systems
;
5621 struct coding_detection_info detect_info
;
5624 = AREF (CODING_ID_ATTRS (coding
->id
), coding_attr_utf_16_bom
);
5625 detect_info
.found
= detect_info
.rejected
= 0;
5626 if (CONSP (coding_systems
)
5627 && detect_coding_utf_16 (coding
, &detect_info
))
5629 if (detect_info
.found
& CATEGORY_MASK_UTF_16_LE
)
5630 setup_coding_system (XCAR (coding_systems
), coding
);
5631 else if (detect_info
.found
& CATEGORY_MASK_UTF_16_BE
)
5632 setup_coding_system (XCDR (coding_systems
), coding
);
5640 struct coding_system
*coding
;
5642 Lisp_Object eol_type
;
5643 unsigned char *p
, *pbeg
, *pend
;
5645 eol_type
= CODING_ID_EOL_TYPE (coding
->id
);
5646 if (EQ (eol_type
, Qunix
))
5649 if (NILP (coding
->dst_object
))
5650 pbeg
= coding
->destination
;
5652 pbeg
= BYTE_POS_ADDR (coding
->dst_pos_byte
);
5653 pend
= pbeg
+ coding
->produced
;
5655 if (VECTORP (eol_type
))
5657 int eol_seen
= EOL_SEEN_NONE
;
5659 for (p
= pbeg
; p
< pend
; p
++)
5662 eol_seen
|= EOL_SEEN_LF
;
5663 else if (*p
== '\r')
5665 if (p
+ 1 < pend
&& *(p
+ 1) == '\n')
5667 eol_seen
|= EOL_SEEN_CRLF
;
5671 eol_seen
|= EOL_SEEN_CR
;
5674 if (eol_seen
!= EOL_SEEN_NONE
5675 && eol_seen
!= EOL_SEEN_LF
5676 && eol_seen
!= EOL_SEEN_CRLF
5677 && eol_seen
!= EOL_SEEN_CR
)
5678 eol_seen
= EOL_SEEN_LF
;
5679 if (eol_seen
!= EOL_SEEN_NONE
)
5680 eol_type
= adjust_coding_eol_type (coding
, eol_seen
);
5683 if (EQ (eol_type
, Qmac
))
5685 for (p
= pbeg
; p
< pend
; p
++)
5689 else if (EQ (eol_type
, Qdos
))
5693 if (NILP (coding
->dst_object
))
5695 /* Start deleting '\r' from the tail to minimize the memory
5697 for (p
= pend
- 2; p
>= pbeg
; p
--)
5700 safe_bcopy ((char *) (p
+ 1), (char *) p
, pend
-- - p
- 1);
5706 int pos_byte
= coding
->dst_pos_byte
;
5707 int pos
= coding
->dst_pos
;
5708 int pos_end
= pos
+ coding
->produced_char
- 1;
5710 while (pos
< pos_end
)
5712 p
= BYTE_POS_ADDR (pos_byte
);
5713 if (*p
== '\r' && p
[1] == '\n')
5715 del_range_2 (pos
, pos_byte
, pos
+ 1, pos_byte
+ 1, 0);
5720 if (coding
->dst_multibyte
)
5721 pos_byte
+= BYTES_BY_CHAR_HEAD (*p
);
5726 coding
->produced
-= n
;
5727 coding
->produced_char
-= n
;
5732 /* Return a translation table (or list of them) from coding system
5733 attribute vector ATTRS for encoding (ENCODEP is nonzero) or
5734 decoding (ENCODEP is zero). */
5737 get_translation_table (attrs
, encodep
, max_lookup
)
5739 int encodep
, *max_lookup
;
5741 Lisp_Object standard
, translation_table
;
5745 translation_table
= CODING_ATTR_ENCODE_TBL (attrs
),
5746 standard
= Vstandard_translation_table_for_encode
;
5748 translation_table
= CODING_ATTR_DECODE_TBL (attrs
),
5749 standard
= Vstandard_translation_table_for_decode
;
5750 if (NILP (translation_table
))
5751 translation_table
= standard
;
5754 if (SYMBOLP (translation_table
))
5755 translation_table
= Fget (translation_table
, Qtranslation_table
);
5756 else if (CONSP (translation_table
))
5758 translation_table
= Fcopy_sequence (translation_table
);
5759 for (val
= translation_table
; CONSP (val
); val
= XCDR (val
))
5760 if (SYMBOLP (XCAR (val
)))
5761 XSETCAR (val
, Fget (XCAR (val
), Qtranslation_table
));
5763 if (CHAR_TABLE_P (standard
))
5765 if (CONSP (translation_table
))
5766 translation_table
= nconc2 (translation_table
,
5767 Fcons (standard
, Qnil
));
5769 translation_table
= Fcons (translation_table
,
5770 Fcons (standard
, Qnil
));
5777 if (CHAR_TABLE_P (translation_table
)
5778 && CHAR_TABLE_EXTRA_SLOTS (XCHAR_TABLE (translation_table
)) > 1)
5780 val
= XCHAR_TABLE (translation_table
)->extras
[1];
5781 if (NATNUMP (val
) && *max_lookup
< XFASTINT (val
))
5782 *max_lookup
= XFASTINT (val
);
5784 else if (CONSP (translation_table
))
5786 Lisp_Object tail
, val
;
5788 for (tail
= translation_table
; CONSP (tail
); tail
= XCDR (tail
))
5789 if (CHAR_TABLE_P (XCAR (tail
))
5790 && CHAR_TABLE_EXTRA_SLOTS (XCHAR_TABLE (XCAR (tail
))) > 1)
5792 val
= XCHAR_TABLE (XCAR (tail
))->extras
[1];
5793 if (NATNUMP (val
) && *max_lookup
< XFASTINT (val
))
5794 *max_lookup
= XFASTINT (val
);
5798 return translation_table
;
5801 #define LOOKUP_TRANSLATION_TABLE(table, c, trans) \
5804 if (CHAR_TABLE_P (table)) \
5806 trans = CHAR_TABLE_REF (table, c); \
5807 if (CHARACTERP (trans)) \
5808 c = XFASTINT (trans), trans = Qnil; \
5810 else if (CONSP (table)) \
5814 for (tail = table; CONSP (tail); tail = XCDR (tail)) \
5815 if (CHAR_TABLE_P (XCAR (tail))) \
5817 trans = CHAR_TABLE_REF (XCAR (tail), c); \
5818 if (CHARACTERP (trans)) \
5819 c = XFASTINT (trans), trans = Qnil; \
5820 else if (! NILP (trans)) \
5828 get_translation (val
, buf
, buf_end
, last_block
, from_nchars
, to_nchars
)
5832 int *from_nchars
, *to_nchars
;
5834 /* VAL is TO or (([FROM-CHAR ...] . TO) ...) where TO is TO-CHAR or
5838 Lisp_Object from
, tail
;
5841 for (tail
= val
; CONSP (tail
); tail
= XCDR (tail
))
5846 for (i
= 0; i
< len
; i
++)
5848 if (buf
+ i
== buf_end
)
5854 if (XINT (AREF (from
, i
)) != buf
[i
])
5868 *buf
= XINT (AREF (val
, 0)), *to_nchars
= ASIZE (val
);
5876 produce_chars (coding
, translation_table
, last_block
)
5877 struct coding_system
*coding
;
5878 Lisp_Object translation_table
;
5881 unsigned char *dst
= coding
->destination
+ coding
->produced
;
5882 unsigned char *dst_end
= coding
->destination
+ coding
->dst_bytes
;
5884 int produced_chars
= 0;
5887 if (! coding
->chars_at_source
)
5889 /* Characters are in coding->charbuf. */
5890 int *buf
= coding
->charbuf
;
5891 int *buf_end
= buf
+ coding
->charbuf_used
;
5893 if (BUFFERP (coding
->src_object
)
5894 && EQ (coding
->src_object
, coding
->dst_object
))
5895 dst_end
= ((unsigned char *) coding
->source
) + coding
->consumed
;
5897 while (buf
< buf_end
)
5903 int from_nchars
= 1, to_nchars
= 1;
5904 Lisp_Object trans
= Qnil
;
5906 LOOKUP_TRANSLATION_TABLE (translation_table
, c
, trans
);
5909 trans
= get_translation (trans
, buf
, buf_end
, last_block
,
5910 &from_nchars
, &to_nchars
);
5916 if (dst
+ MAX_MULTIBYTE_LENGTH
* to_nchars
> dst_end
)
5918 dst
= alloc_destination (coding
,
5920 + MAX_MULTIBYTE_LENGTH
* to_nchars
,
5922 dst_end
= coding
->destination
+ coding
->dst_bytes
;
5925 for (i
= 0; i
< to_nchars
; i
++)
5928 c
= XINT (AREF (trans
, i
));
5929 if (coding
->dst_multibyte
5930 || ! CHAR_BYTE8_P (c
))
5931 CHAR_STRING_ADVANCE (c
, dst
);
5933 *dst
++ = CHAR_TO_BYTE8 (c
);
5935 produced_chars
+= to_nchars
;
5937 while (--from_nchars
> 0)
5941 /* This is an annotation datum. (-C) is the length. */
5944 carryover
= buf_end
- buf
;
5948 const unsigned char *src
= coding
->source
;
5949 const unsigned char *src_end
= src
+ coding
->src_bytes
;
5950 Lisp_Object eol_type
;
5952 eol_type
= CODING_ID_EOL_TYPE (coding
->id
);
5954 if (coding
->src_multibyte
!= coding
->dst_multibyte
)
5956 if (coding
->src_multibyte
)
5963 const unsigned char *src_base
= src
;
5969 if (EQ (eol_type
, Qdos
))
5973 record_conversion_result
5974 (coding
, CODING_RESULT_INSUFFICIENT_SRC
);
5975 goto no_more_source
;
5980 else if (EQ (eol_type
, Qmac
))
5985 coding
->consumed
= src
- coding
->source
;
5987 if (EQ (coding
->src_object
, coding
->dst_object
))
5988 dst_end
= (unsigned char *) src
;
5991 dst
= alloc_destination (coding
, src_end
- src
+ 1,
5993 dst_end
= coding
->destination
+ coding
->dst_bytes
;
5994 coding_set_source (coding
);
5995 src
= coding
->source
+ coding
->consumed
;
5996 src_end
= coding
->source
+ coding
->src_bytes
;
6006 while (src
< src_end
)
6013 if (EQ (eol_type
, Qdos
))
6019 else if (EQ (eol_type
, Qmac
))
6022 if (dst
>= dst_end
- 1)
6024 coding
->consumed
= src
- coding
->source
;
6026 if (EQ (coding
->src_object
, coding
->dst_object
))
6027 dst_end
= (unsigned char *) src
;
6028 if (dst
>= dst_end
- 1)
6030 dst
= alloc_destination (coding
, src_end
- src
+ 2,
6032 dst_end
= coding
->destination
+ coding
->dst_bytes
;
6033 coding_set_source (coding
);
6034 src
= coding
->source
+ coding
->consumed
;
6035 src_end
= coding
->source
+ coding
->src_bytes
;
6043 if (!EQ (coding
->src_object
, coding
->dst_object
))
6045 int require
= coding
->src_bytes
- coding
->dst_bytes
;
6049 EMACS_INT offset
= src
- coding
->source
;
6051 dst
= alloc_destination (coding
, require
, dst
);
6052 coding_set_source (coding
);
6053 src
= coding
->source
+ offset
;
6054 src_end
= coding
->source
+ coding
->src_bytes
;
6057 produced_chars
= coding
->src_chars
;
6058 while (src
< src_end
)
6064 if (EQ (eol_type
, Qdos
))
6071 else if (EQ (eol_type
, Qmac
))
6077 coding
->consumed
= coding
->src_bytes
;
6078 coding
->consumed_char
= coding
->src_chars
;
6081 produced
= dst
- (coding
->destination
+ coding
->produced
);
6082 if (BUFFERP (coding
->dst_object
) && produced_chars
> 0)
6083 insert_from_gap (produced_chars
, produced
);
6084 coding
->produced
+= produced
;
6085 coding
->produced_char
+= produced_chars
;
6089 /* Compose text in CODING->object according to the annotation data at
6090 CHARBUF. CHARBUF is an array:
6091 [ -LENGTH ANNOTATION_MASK FROM TO METHOD COMP_LEN [ COMPONENTS... ] ]
6095 produce_composition (coding
, charbuf
, pos
)
6096 struct coding_system
*coding
;
6102 enum composition_method method
;
6103 Lisp_Object components
;
6106 to
= pos
+ charbuf
[2];
6109 method
= (enum composition_method
) (charbuf
[3]);
6111 if (method
== COMPOSITION_RELATIVE
)
6113 else if (method
>= COMPOSITION_WITH_RULE
6114 && method
<= COMPOSITION_WITH_RULE_ALTCHARS
)
6116 Lisp_Object args
[MAX_COMPOSITION_COMPONENTS
* 2 - 1];
6121 for (i
= 0; i
< len
; i
++)
6123 args
[i
] = make_number (charbuf
[i
]);
6127 components
= (method
== COMPOSITION_WITH_ALTCHARS
6128 ? Fstring (len
, args
) : Fvector (len
, args
));
6132 compose_text (pos
, to
, components
, Qnil
, coding
->dst_object
);
6136 /* Put `charset' property on text in CODING->object according to
6137 the annotation data at CHARBUF. CHARBUF is an array:
6138 [ -LENGTH ANNOTATION_MASK NCHARS CHARSET-ID ]
6142 produce_charset (coding
, charbuf
, pos
)
6143 struct coding_system
*coding
;
6147 EMACS_INT from
= pos
- charbuf
[2];
6148 struct charset
*charset
= CHARSET_FROM_ID (charbuf
[3]);
6150 Fput_text_property (make_number (from
), make_number (pos
),
6151 Qcharset
, CHARSET_NAME (charset
),
6152 coding
->dst_object
);
6156 #define CHARBUF_SIZE 0x4000
6158 #define ALLOC_CONVERSION_WORK_AREA(coding) \
6160 int size = CHARBUF_SIZE;; \
6162 coding->charbuf = NULL; \
6163 while (size > 1024) \
6165 coding->charbuf = (int *) alloca (sizeof (int) * size); \
6166 if (coding->charbuf) \
6170 if (! coding->charbuf) \
6172 record_conversion_result (coding, CODING_RESULT_INSUFFICIENT_MEM); \
6173 return coding->result; \
6175 coding->charbuf_size = size; \
6180 produce_annotation (coding
, pos
)
6181 struct coding_system
*coding
;
6184 int *charbuf
= coding
->charbuf
;
6185 int *charbuf_end
= charbuf
+ coding
->charbuf_used
;
6187 if (NILP (coding
->dst_object
))
6190 while (charbuf
< charbuf_end
)
6196 int len
= -*charbuf
;
6199 case CODING_ANNOTATE_COMPOSITION_MASK
:
6200 produce_composition (coding
, charbuf
, pos
);
6202 case CODING_ANNOTATE_CHARSET_MASK
:
6203 produce_charset (coding
, charbuf
, pos
);
6213 /* Decode the data at CODING->src_object into CODING->dst_object.
6214 CODING->src_object is a buffer, a string, or nil.
6215 CODING->dst_object is a buffer.
6217 If CODING->src_object is a buffer, it must be the current buffer.
6218 In this case, if CODING->src_pos is positive, it is a position of
6219 the source text in the buffer, otherwise, the source text is in the
6220 gap area of the buffer, and CODING->src_pos specifies the offset of
6221 the text from GPT (which must be the same as PT). If this is the
6222 same buffer as CODING->dst_object, CODING->src_pos must be
6225 If CODING->src_object is a string, CODING->src_pos is an index to
6228 If CODING->src_object is nil, CODING->source must already point to
6229 the non-relocatable memory area. In this case, CODING->src_pos is
6230 an offset from CODING->source.
6232 The decoded data is inserted at the current point of the buffer
6237 decode_coding (coding
)
6238 struct coding_system
*coding
;
6241 Lisp_Object undo_list
;
6242 Lisp_Object translation_table
;
6246 if (BUFFERP (coding
->src_object
)
6247 && coding
->src_pos
> 0
6248 && coding
->src_pos
< GPT
6249 && coding
->src_pos
+ coding
->src_chars
> GPT
)
6250 move_gap_both (coding
->src_pos
, coding
->src_pos_byte
);
6253 if (BUFFERP (coding
->dst_object
))
6255 if (current_buffer
!= XBUFFER (coding
->dst_object
))
6256 set_buffer_internal (XBUFFER (coding
->dst_object
));
6258 move_gap_both (PT
, PT_BYTE
);
6259 undo_list
= current_buffer
->undo_list
;
6260 current_buffer
->undo_list
= Qt
;
6263 coding
->consumed
= coding
->consumed_char
= 0;
6264 coding
->produced
= coding
->produced_char
= 0;
6265 coding
->chars_at_source
= 0;
6266 record_conversion_result (coding
, CODING_RESULT_SUCCESS
);
6269 ALLOC_CONVERSION_WORK_AREA (coding
);
6271 attrs
= CODING_ID_ATTRS (coding
->id
);
6272 translation_table
= get_translation_table (attrs
, 0, NULL
);
6277 EMACS_INT pos
= coding
->dst_pos
+ coding
->produced_char
;
6279 coding_set_source (coding
);
6280 coding
->annotated
= 0;
6281 coding
->charbuf_used
= carryover
;
6282 (*(coding
->decoder
)) (coding
);
6283 coding_set_destination (coding
);
6284 carryover
= produce_chars (coding
, translation_table
, 0);
6285 if (coding
->annotated
)
6286 produce_annotation (coding
, pos
);
6287 for (i
= 0; i
< carryover
; i
++)
6289 = coding
->charbuf
[coding
->charbuf_used
- carryover
+ i
];
6291 while (coding
->consumed
< coding
->src_bytes
6292 && (coding
->result
== CODING_RESULT_SUCCESS
6293 || coding
->result
== CODING_RESULT_INVALID_SRC
));
6297 coding_set_destination (coding
);
6298 coding
->charbuf_used
= carryover
;
6299 produce_chars (coding
, translation_table
, 1);
6302 coding
->carryover_bytes
= 0;
6303 if (coding
->consumed
< coding
->src_bytes
)
6305 int nbytes
= coding
->src_bytes
- coding
->consumed
;
6306 const unsigned char *src
;
6308 coding_set_source (coding
);
6309 coding_set_destination (coding
);
6310 src
= coding
->source
+ coding
->consumed
;
6312 if (coding
->mode
& CODING_MODE_LAST_BLOCK
)
6314 /* Flush out unprocessed data as binary chars. We are sure
6315 that the number of data is less than the size of
6317 coding
->charbuf_used
= 0;
6318 while (nbytes
-- > 0)
6323 c
= BYTE8_TO_CHAR (c
);
6324 coding
->charbuf
[coding
->charbuf_used
++] = c
;
6326 produce_chars (coding
, Qnil
, 1);
6330 /* Record unprocessed bytes in coding->carryover. We are
6331 sure that the number of data is less than the size of
6332 coding->carryover. */
6333 unsigned char *p
= coding
->carryover
;
6335 coding
->carryover_bytes
= nbytes
;
6336 while (nbytes
-- > 0)
6339 coding
->consumed
= coding
->src_bytes
;
6342 if (! EQ (CODING_ID_EOL_TYPE (coding
->id
), Qunix
))
6343 decode_eol (coding
);
6344 if (BUFFERP (coding
->dst_object
))
6346 current_buffer
->undo_list
= undo_list
;
6347 record_insert (coding
->dst_pos
, coding
->produced_char
);
6349 return coding
->result
;
6353 /* Extract an annotation datum from a composition starting at POS and
6354 ending before LIMIT of CODING->src_object (buffer or string), store
6355 the data in BUF, set *STOP to a starting position of the next
6356 composition (if any) or to LIMIT, and return the address of the
6357 next element of BUF.
6359 If such an annotation is not found, set *STOP to a starting
6360 position of a composition after POS (if any) or to LIMIT, and
6364 handle_composition_annotation (pos
, limit
, coding
, buf
, stop
)
6365 EMACS_INT pos
, limit
;
6366 struct coding_system
*coding
;
6370 EMACS_INT start
, end
;
6373 if (! find_composition (pos
, limit
, &start
, &end
, &prop
, coding
->src_object
)
6376 else if (start
> pos
)
6382 /* We found a composition. Store the corresponding
6383 annotation data in BUF. */
6385 enum composition_method method
= COMPOSITION_METHOD (prop
);
6386 int nchars
= COMPOSITION_LENGTH (prop
);
6388 ADD_COMPOSITION_DATA (buf
, nchars
, method
);
6389 if (method
!= COMPOSITION_RELATIVE
)
6391 Lisp_Object components
;
6394 components
= COMPOSITION_COMPONENTS (prop
);
6395 if (VECTORP (components
))
6397 len
= XVECTOR (components
)->size
;
6398 for (i
= 0; i
< len
; i
++)
6399 *buf
++ = XINT (AREF (components
, i
));
6401 else if (STRINGP (components
))
6403 len
= SCHARS (components
);
6407 FETCH_STRING_CHAR_ADVANCE (*buf
, components
, i
, i_byte
);
6411 else if (INTEGERP (components
))
6414 *buf
++ = XINT (components
);
6416 else if (CONSP (components
))
6418 for (len
= 0; CONSP (components
);
6419 len
++, components
= XCDR (components
))
6420 *buf
++ = XINT (XCAR (components
));
6428 if (find_composition (end
, limit
, &start
, &end
, &prop
,
6439 /* Extract an annotation datum from a text property `charset' at POS of
6440 CODING->src_object (buffer of string), store the data in BUF, set
6441 *STOP to the position where the value of `charset' property changes
6442 (limiting by LIMIT), and return the address of the next element of
6445 If the property value is nil, set *STOP to the position where the
6446 property value is non-nil (limiting by LIMIT), and return BUF. */
6449 handle_charset_annotation (pos
, limit
, coding
, buf
, stop
)
6450 EMACS_INT pos
, limit
;
6451 struct coding_system
*coding
;
6455 Lisp_Object val
, next
;
6458 val
= Fget_text_property (make_number (pos
), Qcharset
, coding
->src_object
);
6459 if (! NILP (val
) && CHARSETP (val
))
6460 id
= XINT (CHARSET_SYMBOL_ID (val
));
6463 ADD_CHARSET_DATA (buf
, 0, id
);
6464 next
= Fnext_single_property_change (make_number (pos
), Qcharset
,
6466 make_number (limit
));
6467 *stop
= XINT (next
);
6473 consume_chars (coding
, translation_table
, max_lookup
)
6474 struct coding_system
*coding
;
6475 Lisp_Object translation_table
;
6478 int *buf
= coding
->charbuf
;
6479 int *buf_end
= coding
->charbuf
+ coding
->charbuf_size
;
6480 const unsigned char *src
= coding
->source
+ coding
->consumed
;
6481 const unsigned char *src_end
= coding
->source
+ coding
->src_bytes
;
6482 EMACS_INT pos
= coding
->src_pos
+ coding
->consumed_char
;
6483 EMACS_INT end_pos
= coding
->src_pos
+ coding
->src_chars
;
6484 int multibytep
= coding
->src_multibyte
;
6485 Lisp_Object eol_type
;
6487 EMACS_INT stop
, stop_composition
, stop_charset
;
6488 int *lookup_buf
= NULL
;
6490 if (! NILP (translation_table
))
6491 lookup_buf
= alloca (sizeof (int) * max_lookup
);
6493 eol_type
= CODING_ID_EOL_TYPE (coding
->id
);
6494 if (VECTORP (eol_type
))
6497 /* Note: composition handling is not yet implemented. */
6498 coding
->common_flags
&= ~CODING_ANNOTATE_COMPOSITION_MASK
;
6500 if (NILP (coding
->src_object
))
6501 stop
= stop_composition
= stop_charset
= end_pos
;
6504 if (coding
->common_flags
& CODING_ANNOTATE_COMPOSITION_MASK
)
6505 stop
= stop_composition
= pos
;
6507 stop
= stop_composition
= end_pos
;
6508 if (coding
->common_flags
& CODING_ANNOTATE_CHARSET_MASK
)
6509 stop
= stop_charset
= pos
;
6511 stop_charset
= end_pos
;
6514 /* Compensate for CRLF and conversion. */
6515 buf_end
-= 1 + MAX_ANNOTATION_LENGTH
;
6516 while (buf
< buf_end
)
6524 if (pos
== stop_composition
)
6525 buf
= handle_composition_annotation (pos
, end_pos
, coding
,
6526 buf
, &stop_composition
);
6527 if (pos
== stop_charset
)
6528 buf
= handle_charset_annotation (pos
, end_pos
, coding
,
6529 buf
, &stop_charset
);
6530 stop
= (stop_composition
< stop_charset
6531 ? stop_composition
: stop_charset
);
6538 if (coding
->encoder
== encode_coding_raw_text
)
6540 else if ((bytes
= MULTIBYTE_LENGTH (src
, src_end
)) > 0)
6541 c
= STRING_CHAR_ADVANCE (src
), pos
+= bytes
;
6543 c
= BYTE8_TO_CHAR (*src
), src
++, pos
++;
6546 c
= STRING_CHAR_ADVANCE (src
), pos
++;
6547 if ((c
== '\r') && (coding
->mode
& CODING_MODE_SELECTIVE_DISPLAY
))
6549 if (! EQ (eol_type
, Qunix
))
6553 if (EQ (eol_type
, Qdos
))
6561 LOOKUP_TRANSLATION_TABLE (translation_table
, c
, trans
);
6566 int from_nchars
= 1, to_nchars
= 1;
6567 int *lookup_buf_end
;
6568 const unsigned char *p
= src
;
6572 for (i
= 1; i
< max_lookup
&& p
< src_end
; i
++)
6573 lookup_buf
[i
] = STRING_CHAR_ADVANCE (p
);
6574 lookup_buf_end
= lookup_buf
+ i
;
6575 trans
= get_translation (trans
, lookup_buf
, lookup_buf_end
, 1,
6576 &from_nchars
, &to_nchars
);
6578 || buf
+ to_nchars
> buf_end
)
6580 *buf
++ = *lookup_buf
;
6581 for (i
= 1; i
< to_nchars
; i
++)
6582 *buf
++ = XINT (AREF (trans
, i
));
6583 for (i
= 1; i
< from_nchars
; i
++, pos
++)
6584 src
+= MULTIBYTE_LENGTH_NO_CHECK (src
);
6588 coding
->consumed
= src
- coding
->source
;
6589 coding
->consumed_char
= pos
- coding
->src_pos
;
6590 coding
->charbuf_used
= buf
- coding
->charbuf
;
6591 coding
->chars_at_source
= 0;
6595 /* Encode the text at CODING->src_object into CODING->dst_object.
6596 CODING->src_object is a buffer or a string.
6597 CODING->dst_object is a buffer or nil.
6599 If CODING->src_object is a buffer, it must be the current buffer.
6600 In this case, if CODING->src_pos is positive, it is a position of
6601 the source text in the buffer, otherwise. the source text is in the
6602 gap area of the buffer, and coding->src_pos specifies the offset of
6603 the text from GPT (which must be the same as PT). If this is the
6604 same buffer as CODING->dst_object, CODING->src_pos must be
6605 negative and CODING should not have `pre-write-conversion'.
6607 If CODING->src_object is a string, CODING should not have
6608 `pre-write-conversion'.
6610 If CODING->dst_object is a buffer, the encoded data is inserted at
6611 the current point of that buffer.
6613 If CODING->dst_object is nil, the encoded data is placed at the
6614 memory area specified by CODING->destination. */
6617 encode_coding (coding
)
6618 struct coding_system
*coding
;
6621 Lisp_Object translation_table
;
6624 attrs
= CODING_ID_ATTRS (coding
->id
);
6625 if (coding
->encoder
== encode_coding_raw_text
)
6626 translation_table
= Qnil
, max_lookup
= 0;
6628 translation_table
= get_translation_table (attrs
, 1, &max_lookup
);
6630 if (BUFFERP (coding
->dst_object
))
6632 set_buffer_internal (XBUFFER (coding
->dst_object
));
6633 coding
->dst_multibyte
6634 = ! NILP (current_buffer
->enable_multibyte_characters
);
6637 coding
->consumed
= coding
->consumed_char
= 0;
6638 coding
->produced
= coding
->produced_char
= 0;
6639 record_conversion_result (coding
, CODING_RESULT_SUCCESS
);
6642 ALLOC_CONVERSION_WORK_AREA (coding
);
6645 coding_set_source (coding
);
6646 consume_chars (coding
, translation_table
, max_lookup
);
6647 coding_set_destination (coding
);
6648 (*(coding
->encoder
)) (coding
);
6649 } while (coding
->consumed_char
< coding
->src_chars
);
6651 if (BUFFERP (coding
->dst_object
) && coding
->produced_char
> 0)
6652 insert_from_gap (coding
->produced_char
, coding
->produced
);
6654 return (coding
->result
);
6658 /* Name (or base name) of work buffer for code conversion. */
6659 static Lisp_Object Vcode_conversion_workbuf_name
;
6661 /* A working buffer used by the top level conversion. Once it is
6662 created, it is never destroyed. It has the name
6663 Vcode_conversion_workbuf_name. The other working buffers are
6664 destroyed after the use is finished, and their names are modified
6665 versions of Vcode_conversion_workbuf_name. */
6666 static Lisp_Object Vcode_conversion_reused_workbuf
;
6668 /* 1 iff Vcode_conversion_reused_workbuf is already in use. */
6669 static int reused_workbuf_in_use
;
6672 /* Return a working buffer of code convesion. MULTIBYTE specifies the
6673 multibyteness of returning buffer. */
6676 make_conversion_work_buffer (multibyte
)
6679 Lisp_Object name
, workbuf
;
6680 struct buffer
*current
;
6682 if (reused_workbuf_in_use
++)
6684 name
= Fgenerate_new_buffer_name (Vcode_conversion_workbuf_name
, Qnil
);
6685 workbuf
= Fget_buffer_create (name
);
6689 name
= Vcode_conversion_workbuf_name
;
6690 workbuf
= Fget_buffer_create (name
);
6691 if (NILP (Vcode_conversion_reused_workbuf
))
6692 Vcode_conversion_reused_workbuf
= workbuf
;
6694 current
= current_buffer
;
6695 set_buffer_internal (XBUFFER (workbuf
));
6697 current_buffer
->undo_list
= Qt
;
6698 current_buffer
->enable_multibyte_characters
= multibyte
? Qt
: Qnil
;
6699 set_buffer_internal (current
);
6705 code_conversion_restore (arg
)
6708 Lisp_Object current
, workbuf
;
6709 struct gcpro gcpro1
;
6712 current
= XCAR (arg
);
6713 workbuf
= XCDR (arg
);
6714 if (! NILP (workbuf
))
6716 if (EQ (workbuf
, Vcode_conversion_reused_workbuf
))
6717 reused_workbuf_in_use
= 0;
6718 else if (! NILP (Fbuffer_live_p (workbuf
)))
6719 Fkill_buffer (workbuf
);
6721 set_buffer_internal (XBUFFER (current
));
6727 code_conversion_save (with_work_buf
, multibyte
)
6728 int with_work_buf
, multibyte
;
6730 Lisp_Object workbuf
= Qnil
;
6733 workbuf
= make_conversion_work_buffer (multibyte
);
6734 record_unwind_protect (code_conversion_restore
,
6735 Fcons (Fcurrent_buffer (), workbuf
));
6740 decode_coding_gap (coding
, chars
, bytes
)
6741 struct coding_system
*coding
;
6742 EMACS_INT chars
, bytes
;
6744 int count
= specpdl_ptr
- specpdl
;
6747 code_conversion_save (0, 0);
6749 coding
->src_object
= Fcurrent_buffer ();
6750 coding
->src_chars
= chars
;
6751 coding
->src_bytes
= bytes
;
6752 coding
->src_pos
= -chars
;
6753 coding
->src_pos_byte
= -bytes
;
6754 coding
->src_multibyte
= chars
< bytes
;
6755 coding
->dst_object
= coding
->src_object
;
6756 coding
->dst_pos
= PT
;
6757 coding
->dst_pos_byte
= PT_BYTE
;
6758 coding
->dst_multibyte
= ! NILP (current_buffer
->enable_multibyte_characters
);
6760 if (CODING_REQUIRE_DETECTION (coding
))
6761 detect_coding (coding
);
6763 coding
->mode
|= CODING_MODE_LAST_BLOCK
;
6764 current_buffer
->text
->inhibit_shrinking
= 1;
6765 decode_coding (coding
);
6766 current_buffer
->text
->inhibit_shrinking
= 0;
6768 attrs
= CODING_ID_ATTRS (coding
->id
);
6769 if (! NILP (CODING_ATTR_POST_READ (attrs
)))
6771 EMACS_INT prev_Z
= Z
, prev_Z_BYTE
= Z_BYTE
;
6774 TEMP_SET_PT_BOTH (coding
->dst_pos
, coding
->dst_pos_byte
);
6775 val
= call1 (CODING_ATTR_POST_READ (attrs
),
6776 make_number (coding
->produced_char
));
6778 coding
->produced_char
+= Z
- prev_Z
;
6779 coding
->produced
+= Z_BYTE
- prev_Z_BYTE
;
6782 unbind_to (count
, Qnil
);
6783 return coding
->result
;
6787 encode_coding_gap (coding
, chars
, bytes
)
6788 struct coding_system
*coding
;
6789 EMACS_INT chars
, bytes
;
6791 int count
= specpdl_ptr
- specpdl
;
6793 code_conversion_save (0, 0);
6795 coding
->src_object
= Fcurrent_buffer ();
6796 coding
->src_chars
= chars
;
6797 coding
->src_bytes
= bytes
;
6798 coding
->src_pos
= -chars
;
6799 coding
->src_pos_byte
= -bytes
;
6800 coding
->src_multibyte
= chars
< bytes
;
6801 coding
->dst_object
= coding
->src_object
;
6802 coding
->dst_pos
= PT
;
6803 coding
->dst_pos_byte
= PT_BYTE
;
6805 encode_coding (coding
);
6807 unbind_to (count
, Qnil
);
6808 return coding
->result
;
6812 /* Decode the text in the range FROM/FROM_BYTE and TO/TO_BYTE in
6813 SRC_OBJECT into DST_OBJECT by coding context CODING.
6815 SRC_OBJECT is a buffer, a string, or Qnil.
6817 If it is a buffer, the text is at point of the buffer. FROM and TO
6818 are positions in the buffer.
6820 If it is a string, the text is at the beginning of the string.
6821 FROM and TO are indices to the string.
6823 If it is nil, the text is at coding->source. FROM and TO are
6824 indices to coding->source.
6826 DST_OBJECT is a buffer, Qt, or Qnil.
6828 If it is a buffer, the decoded text is inserted at point of the
6829 buffer. If the buffer is the same as SRC_OBJECT, the source text
6832 If it is Qt, a string is made from the decoded text, and
6833 set in CODING->dst_object.
6835 If it is Qnil, the decoded text is stored at CODING->destination.
6836 The caller must allocate CODING->dst_bytes bytes at
6837 CODING->destination by xmalloc. If the decoded text is longer than
6838 CODING->dst_bytes, CODING->destination is relocated by xrealloc.
6842 decode_coding_object (coding
, src_object
, from
, from_byte
, to
, to_byte
,
6844 struct coding_system
*coding
;
6845 Lisp_Object src_object
;
6846 EMACS_INT from
, from_byte
, to
, to_byte
;
6847 Lisp_Object dst_object
;
6849 int count
= specpdl_ptr
- specpdl
;
6850 unsigned char *destination
;
6851 EMACS_INT dst_bytes
;
6852 EMACS_INT chars
= to
- from
;
6853 EMACS_INT bytes
= to_byte
- from_byte
;
6856 int saved_pt
= -1, saved_pt_byte
;
6857 int need_marker_adjustment
= 0;
6859 buffer
= Fcurrent_buffer ();
6861 if (NILP (dst_object
))
6863 destination
= coding
->destination
;
6864 dst_bytes
= coding
->dst_bytes
;
6867 coding
->src_object
= src_object
;
6868 coding
->src_chars
= chars
;
6869 coding
->src_bytes
= bytes
;
6870 coding
->src_multibyte
= chars
< bytes
;
6872 if (STRINGP (src_object
))
6874 coding
->src_pos
= from
;
6875 coding
->src_pos_byte
= from_byte
;
6877 else if (BUFFERP (src_object
))
6879 set_buffer_internal (XBUFFER (src_object
));
6881 move_gap_both (from
, from_byte
);
6882 if (EQ (src_object
, dst_object
))
6884 struct Lisp_Marker
*tail
;
6886 for (tail
= BUF_MARKERS (current_buffer
); tail
; tail
= tail
->next
)
6888 tail
->need_adjustment
6889 = tail
->charpos
== (tail
->insertion_type
? from
: to
);
6890 need_marker_adjustment
|= tail
->need_adjustment
;
6892 saved_pt
= PT
, saved_pt_byte
= PT_BYTE
;
6893 TEMP_SET_PT_BOTH (from
, from_byte
);
6894 del_range_both (from
, from_byte
, to
, to_byte
, 1);
6895 coding
->src_pos
= -chars
;
6896 coding
->src_pos_byte
= -bytes
;
6900 coding
->src_pos
= from
;
6901 coding
->src_pos_byte
= from_byte
;
6905 if (CODING_REQUIRE_DETECTION (coding
))
6906 detect_coding (coding
);
6907 attrs
= CODING_ID_ATTRS (coding
->id
);
6909 if (EQ (dst_object
, Qt
)
6910 || (! NILP (CODING_ATTR_POST_READ (attrs
))
6911 && NILP (dst_object
)))
6913 coding
->dst_object
= code_conversion_save (1, 1);
6914 coding
->dst_pos
= BEG
;
6915 coding
->dst_pos_byte
= BEG_BYTE
;
6916 coding
->dst_multibyte
= 1;
6918 else if (BUFFERP (dst_object
))
6920 code_conversion_save (0, 0);
6921 coding
->dst_object
= dst_object
;
6922 coding
->dst_pos
= BUF_PT (XBUFFER (dst_object
));
6923 coding
->dst_pos_byte
= BUF_PT_BYTE (XBUFFER (dst_object
));
6924 coding
->dst_multibyte
6925 = ! NILP (XBUFFER (dst_object
)->enable_multibyte_characters
);
6929 code_conversion_save (0, 0);
6930 coding
->dst_object
= Qnil
;
6931 coding
->dst_multibyte
= 1;
6934 decode_coding (coding
);
6936 if (BUFFERP (coding
->dst_object
))
6937 set_buffer_internal (XBUFFER (coding
->dst_object
));
6939 if (! NILP (CODING_ATTR_POST_READ (attrs
)))
6941 struct gcpro gcpro1
, gcpro2
;
6942 EMACS_INT prev_Z
= Z
, prev_Z_BYTE
= Z_BYTE
;
6945 TEMP_SET_PT_BOTH (coding
->dst_pos
, coding
->dst_pos_byte
);
6946 GCPRO2 (coding
->src_object
, coding
->dst_object
);
6947 val
= safe_call1 (CODING_ATTR_POST_READ (attrs
),
6948 make_number (coding
->produced_char
));
6951 coding
->produced_char
+= Z
- prev_Z
;
6952 coding
->produced
+= Z_BYTE
- prev_Z_BYTE
;
6955 if (EQ (dst_object
, Qt
))
6957 coding
->dst_object
= Fbuffer_string ();
6959 else if (NILP (dst_object
) && BUFFERP (coding
->dst_object
))
6961 set_buffer_internal (XBUFFER (coding
->dst_object
));
6962 if (dst_bytes
< coding
->produced
)
6965 = (unsigned char *) xrealloc (destination
, coding
->produced
);
6968 record_conversion_result (coding
,
6969 CODING_RESULT_INSUFFICIENT_DST
);
6970 unbind_to (count
, Qnil
);
6973 if (BEGV
< GPT
&& GPT
< BEGV
+ coding
->produced_char
)
6974 move_gap_both (BEGV
, BEGV_BYTE
);
6975 bcopy (BEGV_ADDR
, destination
, coding
->produced
);
6976 coding
->destination
= destination
;
6982 /* This is the case of:
6983 (BUFFERP (src_object) && EQ (src_object, dst_object))
6984 As we have moved PT while replacing the original buffer
6985 contents, we must recover it now. */
6986 set_buffer_internal (XBUFFER (src_object
));
6987 if (saved_pt
< from
)
6988 TEMP_SET_PT_BOTH (saved_pt
, saved_pt_byte
);
6989 else if (saved_pt
< from
+ chars
)
6990 TEMP_SET_PT_BOTH (from
, from_byte
);
6991 else if (! NILP (current_buffer
->enable_multibyte_characters
))
6992 TEMP_SET_PT_BOTH (saved_pt
+ (coding
->produced_char
- chars
),
6993 saved_pt_byte
+ (coding
->produced
- bytes
));
6995 TEMP_SET_PT_BOTH (saved_pt
+ (coding
->produced
- bytes
),
6996 saved_pt_byte
+ (coding
->produced
- bytes
));
6998 if (need_marker_adjustment
)
7000 struct Lisp_Marker
*tail
;
7002 for (tail
= BUF_MARKERS (current_buffer
); tail
; tail
= tail
->next
)
7003 if (tail
->need_adjustment
)
7005 tail
->need_adjustment
= 0;
7006 if (tail
->insertion_type
)
7008 tail
->bytepos
= from_byte
;
7009 tail
->charpos
= from
;
7013 tail
->bytepos
= from_byte
+ coding
->produced
;
7015 = (NILP (current_buffer
->enable_multibyte_characters
)
7016 ? tail
->bytepos
: from
+ coding
->produced_char
);
7022 unbind_to (count
, coding
->dst_object
);
7027 encode_coding_object (coding
, src_object
, from
, from_byte
, to
, to_byte
,
7029 struct coding_system
*coding
;
7030 Lisp_Object src_object
;
7031 EMACS_INT from
, from_byte
, to
, to_byte
;
7032 Lisp_Object dst_object
;
7034 int count
= specpdl_ptr
- specpdl
;
7035 EMACS_INT chars
= to
- from
;
7036 EMACS_INT bytes
= to_byte
- from_byte
;
7039 int saved_pt
= -1, saved_pt_byte
;
7040 int need_marker_adjustment
= 0;
7041 int kill_src_buffer
= 0;
7043 buffer
= Fcurrent_buffer ();
7045 coding
->src_object
= src_object
;
7046 coding
->src_chars
= chars
;
7047 coding
->src_bytes
= bytes
;
7048 coding
->src_multibyte
= chars
< bytes
;
7050 attrs
= CODING_ID_ATTRS (coding
->id
);
7052 if (EQ (src_object
, dst_object
))
7054 struct Lisp_Marker
*tail
;
7056 for (tail
= BUF_MARKERS (current_buffer
); tail
; tail
= tail
->next
)
7058 tail
->need_adjustment
7059 = tail
->charpos
== (tail
->insertion_type
? from
: to
);
7060 need_marker_adjustment
|= tail
->need_adjustment
;
7064 if (! NILP (CODING_ATTR_PRE_WRITE (attrs
)))
7066 coding
->src_object
= code_conversion_save (1, coding
->src_multibyte
);
7067 set_buffer_internal (XBUFFER (coding
->src_object
));
7068 if (STRINGP (src_object
))
7069 insert_from_string (src_object
, from
, from_byte
, chars
, bytes
, 0);
7070 else if (BUFFERP (src_object
))
7071 insert_from_buffer (XBUFFER (src_object
), from
, chars
, 0);
7073 insert_1_both (coding
->source
+ from
, chars
, bytes
, 0, 0, 0);
7075 if (EQ (src_object
, dst_object
))
7077 set_buffer_internal (XBUFFER (src_object
));
7078 saved_pt
= PT
, saved_pt_byte
= PT_BYTE
;
7079 del_range_both (from
, from_byte
, to
, to_byte
, 1);
7080 set_buffer_internal (XBUFFER (coding
->src_object
));
7084 Lisp_Object args
[3];
7086 args
[0] = CODING_ATTR_PRE_WRITE (attrs
);
7087 args
[1] = make_number (BEG
);
7088 args
[2] = make_number (Z
);
7089 safe_call (3, args
);
7091 if (XBUFFER (coding
->src_object
) != current_buffer
)
7092 kill_src_buffer
= 1;
7093 coding
->src_object
= Fcurrent_buffer ();
7095 move_gap_both (BEG
, BEG_BYTE
);
7096 coding
->src_chars
= Z
- BEG
;
7097 coding
->src_bytes
= Z_BYTE
- BEG_BYTE
;
7098 coding
->src_pos
= BEG
;
7099 coding
->src_pos_byte
= BEG_BYTE
;
7100 coding
->src_multibyte
= Z
< Z_BYTE
;
7102 else if (STRINGP (src_object
))
7104 code_conversion_save (0, 0);
7105 coding
->src_pos
= from
;
7106 coding
->src_pos_byte
= from_byte
;
7108 else if (BUFFERP (src_object
))
7110 code_conversion_save (0, 0);
7111 set_buffer_internal (XBUFFER (src_object
));
7112 if (EQ (src_object
, dst_object
))
7114 saved_pt
= PT
, saved_pt_byte
= PT_BYTE
;
7115 coding
->src_object
= del_range_1 (from
, to
, 1, 1);
7116 coding
->src_pos
= 0;
7117 coding
->src_pos_byte
= 0;
7121 if (from
< GPT
&& to
>= GPT
)
7122 move_gap_both (from
, from_byte
);
7123 coding
->src_pos
= from
;
7124 coding
->src_pos_byte
= from_byte
;
7128 code_conversion_save (0, 0);
7130 if (BUFFERP (dst_object
))
7132 coding
->dst_object
= dst_object
;
7133 if (EQ (src_object
, dst_object
))
7135 coding
->dst_pos
= from
;
7136 coding
->dst_pos_byte
= from_byte
;
7140 coding
->dst_pos
= BUF_PT (XBUFFER (dst_object
));
7141 coding
->dst_pos_byte
= BUF_PT_BYTE (XBUFFER (dst_object
));
7143 coding
->dst_multibyte
7144 = ! NILP (XBUFFER (dst_object
)->enable_multibyte_characters
);
7146 else if (EQ (dst_object
, Qt
))
7148 coding
->dst_object
= Qnil
;
7149 coding
->dst_bytes
= coding
->src_chars
;
7150 if (coding
->dst_bytes
== 0)
7151 coding
->dst_bytes
= 1;
7152 coding
->destination
= (unsigned char *) xmalloc (coding
->dst_bytes
);
7153 coding
->dst_multibyte
= 0;
7157 coding
->dst_object
= Qnil
;
7158 coding
->dst_multibyte
= 0;
7161 encode_coding (coding
);
7163 if (EQ (dst_object
, Qt
))
7165 if (BUFFERP (coding
->dst_object
))
7166 coding
->dst_object
= Fbuffer_string ();
7170 = make_unibyte_string ((char *) coding
->destination
,
7172 xfree (coding
->destination
);
7178 /* This is the case of:
7179 (BUFFERP (src_object) && EQ (src_object, dst_object))
7180 As we have moved PT while replacing the original buffer
7181 contents, we must recover it now. */
7182 set_buffer_internal (XBUFFER (src_object
));
7183 if (saved_pt
< from
)
7184 TEMP_SET_PT_BOTH (saved_pt
, saved_pt_byte
);
7185 else if (saved_pt
< from
+ chars
)
7186 TEMP_SET_PT_BOTH (from
, from_byte
);
7187 else if (! NILP (current_buffer
->enable_multibyte_characters
))
7188 TEMP_SET_PT_BOTH (saved_pt
+ (coding
->produced_char
- chars
),
7189 saved_pt_byte
+ (coding
->produced
- bytes
));
7191 TEMP_SET_PT_BOTH (saved_pt
+ (coding
->produced
- bytes
),
7192 saved_pt_byte
+ (coding
->produced
- bytes
));
7194 if (need_marker_adjustment
)
7196 struct Lisp_Marker
*tail
;
7198 for (tail
= BUF_MARKERS (current_buffer
); tail
; tail
= tail
->next
)
7199 if (tail
->need_adjustment
)
7201 tail
->need_adjustment
= 0;
7202 if (tail
->insertion_type
)
7204 tail
->bytepos
= from_byte
;
7205 tail
->charpos
= from
;
7209 tail
->bytepos
= from_byte
+ coding
->produced
;
7211 = (NILP (current_buffer
->enable_multibyte_characters
)
7212 ? tail
->bytepos
: from
+ coding
->produced_char
);
7218 if (kill_src_buffer
)
7219 Fkill_buffer (coding
->src_object
);
7220 unbind_to (count
, Qnil
);
7225 preferred_coding_system ()
7227 int id
= coding_categories
[coding_priorities
[0]].id
;
7229 return CODING_ID_NAME (id
);
7234 /*** 8. Emacs Lisp library functions ***/
7236 DEFUN ("coding-system-p", Fcoding_system_p
, Scoding_system_p
, 1, 1, 0,
7237 doc
: /* Return t if OBJECT is nil or a coding-system.
7238 See the documentation of `define-coding-system' for information
7239 about coding-system objects. */)
7244 || CODING_SYSTEM_ID (obj
) >= 0)
7247 || NILP (Fget (obj
, Qcoding_system_define_form
)))
7252 DEFUN ("read-non-nil-coding-system", Fread_non_nil_coding_system
,
7253 Sread_non_nil_coding_system
, 1, 1, 0,
7254 doc
: /* Read a coding system from the minibuffer, prompting with string PROMPT. */)
7261 val
= Fcompleting_read (prompt
, Vcoding_system_alist
, Qnil
,
7262 Qt
, Qnil
, Qcoding_system_history
, Qnil
, Qnil
);
7264 while (SCHARS (val
) == 0);
7265 return (Fintern (val
, Qnil
));
7268 DEFUN ("read-coding-system", Fread_coding_system
, Sread_coding_system
, 1, 2, 0,
7269 doc
: /* Read a coding system from the minibuffer, prompting with string PROMPT.
7270 If the user enters null input, return second argument DEFAULT-CODING-SYSTEM.
7271 Ignores case when completing coding systems (all Emacs coding systems
7272 are lower-case). */)
7273 (prompt
, default_coding_system
)
7274 Lisp_Object prompt
, default_coding_system
;
7277 int count
= SPECPDL_INDEX ();
7279 if (SYMBOLP (default_coding_system
))
7280 default_coding_system
= SYMBOL_NAME (default_coding_system
);
7281 specbind (Qcompletion_ignore_case
, Qt
);
7282 val
= Fcompleting_read (prompt
, Vcoding_system_alist
, Qnil
,
7283 Qt
, Qnil
, Qcoding_system_history
,
7284 default_coding_system
, Qnil
);
7285 unbind_to (count
, Qnil
);
7286 return (SCHARS (val
) == 0 ? Qnil
: Fintern (val
, Qnil
));
7289 DEFUN ("check-coding-system", Fcheck_coding_system
, Scheck_coding_system
,
7291 doc
: /* Check validity of CODING-SYSTEM.
7292 If valid, return CODING-SYSTEM, else signal a `coding-system-error' error.
7293 It is valid if it is nil or a symbol defined as a coding system by the
7294 function `define-coding-system'. */)
7296 Lisp_Object coding_system
;
7298 Lisp_Object define_form
;
7300 define_form
= Fget (coding_system
, Qcoding_system_define_form
);
7301 if (! NILP (define_form
))
7303 Fput (coding_system
, Qcoding_system_define_form
, Qnil
);
7304 safe_eval (define_form
);
7306 if (!NILP (Fcoding_system_p (coding_system
)))
7307 return coding_system
;
7308 xsignal1 (Qcoding_system_error
, coding_system
);
7312 /* Detect how the bytes at SRC of length SRC_BYTES are encoded. If
7313 HIGHEST is nonzero, return the coding system of the highest
7314 priority among the detected coding systems. Otherwize return a
7315 list of detected coding systems sorted by their priorities. If
7316 MULTIBYTEP is nonzero, it is assumed that the bytes are in correct
7317 multibyte form but contains only ASCII and eight-bit chars.
7318 Otherwise, the bytes are raw bytes.
7320 CODING-SYSTEM controls the detection as below:
7322 If it is nil, detect both text-format and eol-format. If the
7323 text-format part of CODING-SYSTEM is already specified
7324 (e.g. `iso-latin-1'), detect only eol-format. If the eol-format
7325 part of CODING-SYSTEM is already specified (e.g. `undecided-unix'),
7326 detect only text-format. */
7329 detect_coding_system (src
, src_chars
, src_bytes
, highest
, multibytep
,
7331 const unsigned char *src
;
7332 int src_chars
, src_bytes
, highest
;
7334 Lisp_Object coding_system
;
7336 const unsigned char *src_end
= src
+ src_bytes
;
7337 Lisp_Object attrs
, eol_type
;
7339 struct coding_system coding
;
7341 struct coding_detection_info detect_info
;
7342 enum coding_category base_category
;
7344 if (NILP (coding_system
))
7345 coding_system
= Qundecided
;
7346 setup_coding_system (coding_system
, &coding
);
7347 attrs
= CODING_ID_ATTRS (coding
.id
);
7348 eol_type
= CODING_ID_EOL_TYPE (coding
.id
);
7349 coding_system
= CODING_ATTR_BASE_NAME (attrs
);
7351 coding
.source
= src
;
7352 coding
.src_chars
= src_chars
;
7353 coding
.src_bytes
= src_bytes
;
7354 coding
.src_multibyte
= multibytep
;
7355 coding
.consumed
= 0;
7356 coding
.mode
|= CODING_MODE_LAST_BLOCK
;
7358 detect_info
.checked
= detect_info
.found
= detect_info
.rejected
= 0;
7360 /* At first, detect text-format if necessary. */
7361 base_category
= XINT (CODING_ATTR_CATEGORY (attrs
));
7362 if (base_category
== coding_category_undecided
)
7364 enum coding_category category
;
7365 struct coding_system
*this;
7368 /* Skip all ASCII bytes except for a few ISO2022 controls. */
7369 for (i
= 0; src
< src_end
; i
++, src
++)
7375 && (c
== ISO_CODE_ESC
|| c
== ISO_CODE_SI
|| c
== ISO_CODE_SO
)
7376 && ! inhibit_iso_escape_detection
)
7378 coding
.head_ascii
= src
- coding
.source
;
7379 if (detect_coding_iso_2022 (&coding
, &detect_info
))
7381 /* We have scanned the whole data. */
7382 if (! (detect_info
.rejected
& CATEGORY_MASK_ISO_7_ELSE
))
7383 /* We didn't find an 8-bit code. */
7389 coding
.head_ascii
= src
- coding
.source
;
7392 || detect_info
.found
)
7395 /* As all bytes are 7-bit, we can ignore non-ISO-2022 codings. */
7396 for (i
= 0; i
< coding_category_raw_text
; i
++)
7398 category
= coding_priorities
[i
];
7399 this = coding_categories
+ category
;
7400 if (detect_info
.found
& (1 << category
))
7404 for (i
= 0; i
< coding_category_raw_text
; i
++)
7406 category
= coding_priorities
[i
];
7407 this = coding_categories
+ category
;
7411 /* No coding system of this category is defined. */
7412 detect_info
.rejected
|= (1 << category
);
7414 else if (category
>= coding_category_raw_text
)
7416 else if (detect_info
.checked
& (1 << category
))
7419 && (detect_info
.found
& (1 << category
)))
7424 if ((*(this->detector
)) (&coding
, &detect_info
)
7426 && (detect_info
.found
& (1 << category
)))
7428 if (category
== coding_category_utf_16_auto
)
7430 if (detect_info
.found
& CATEGORY_MASK_UTF_16_LE
)
7431 category
= coding_category_utf_16_le
;
7433 category
= coding_category_utf_16_be
;
7441 if (detect_info
.rejected
== CATEGORY_MASK_ANY
)
7443 detect_info
.found
= CATEGORY_MASK_RAW_TEXT
;
7444 id
= coding_categories
[coding_category_raw_text
].id
;
7445 val
= Fcons (make_number (id
), Qnil
);
7447 else if (! detect_info
.rejected
&& ! detect_info
.found
)
7449 detect_info
.found
= CATEGORY_MASK_ANY
;
7450 id
= coding_categories
[coding_category_undecided
].id
;
7451 val
= Fcons (make_number (id
), Qnil
);
7455 if (detect_info
.found
)
7457 detect_info
.found
= 1 << category
;
7458 val
= Fcons (make_number (this->id
), Qnil
);
7461 for (i
= 0; i
< coding_category_raw_text
; i
++)
7462 if (! (detect_info
.rejected
& (1 << coding_priorities
[i
])))
7464 detect_info
.found
= 1 << coding_priorities
[i
];
7465 id
= coding_categories
[coding_priorities
[i
]].id
;
7466 val
= Fcons (make_number (id
), Qnil
);
7472 int mask
= detect_info
.rejected
| detect_info
.found
;
7476 for (i
= coding_category_raw_text
- 1; i
>= 0; i
--)
7478 category
= coding_priorities
[i
];
7479 if (! (mask
& (1 << category
)))
7481 found
|= 1 << category
;
7482 id
= coding_categories
[category
].id
;
7484 val
= Fcons (make_number (id
), val
);
7487 for (i
= coding_category_raw_text
- 1; i
>= 0; i
--)
7489 category
= coding_priorities
[i
];
7490 if (detect_info
.found
& (1 << category
))
7492 id
= coding_categories
[category
].id
;
7493 val
= Fcons (make_number (id
), val
);
7496 detect_info
.found
|= found
;
7499 else if (base_category
== coding_category_utf_16_auto
)
7501 if (detect_coding_utf_16 (&coding
, &detect_info
))
7503 struct coding_system
*this;
7505 if (detect_info
.found
& CATEGORY_MASK_UTF_16_LE
)
7506 this = coding_categories
+ coding_category_utf_16_le
;
7507 else if (detect_info
.found
& CATEGORY_MASK_UTF_16_BE
)
7508 this = coding_categories
+ coding_category_utf_16_be
;
7509 else if (detect_info
.rejected
& CATEGORY_MASK_UTF_16_LE_NOSIG
)
7510 this = coding_categories
+ coding_category_utf_16_be_nosig
;
7512 this = coding_categories
+ coding_category_utf_16_le_nosig
;
7513 val
= Fcons (make_number (this->id
), Qnil
);
7518 detect_info
.found
= 1 << XINT (CODING_ATTR_CATEGORY (attrs
));
7519 val
= Fcons (make_number (coding
.id
), Qnil
);
7522 /* Then, detect eol-format if necessary. */
7524 int normal_eol
= -1, utf_16_be_eol
= -1, utf_16_le_eol
;
7527 if (VECTORP (eol_type
))
7529 if (detect_info
.found
& ~CATEGORY_MASK_UTF_16
)
7530 normal_eol
= detect_eol (coding
.source
, src_bytes
,
7531 coding_category_raw_text
);
7532 if (detect_info
.found
& (CATEGORY_MASK_UTF_16_BE
7533 | CATEGORY_MASK_UTF_16_BE_NOSIG
))
7534 utf_16_be_eol
= detect_eol (coding
.source
, src_bytes
,
7535 coding_category_utf_16_be
);
7536 if (detect_info
.found
& (CATEGORY_MASK_UTF_16_LE
7537 | CATEGORY_MASK_UTF_16_LE_NOSIG
))
7538 utf_16_le_eol
= detect_eol (coding
.source
, src_bytes
,
7539 coding_category_utf_16_le
);
7543 if (EQ (eol_type
, Qunix
))
7544 normal_eol
= utf_16_be_eol
= utf_16_le_eol
= EOL_SEEN_LF
;
7545 else if (EQ (eol_type
, Qdos
))
7546 normal_eol
= utf_16_be_eol
= utf_16_le_eol
= EOL_SEEN_CRLF
;
7548 normal_eol
= utf_16_be_eol
= utf_16_le_eol
= EOL_SEEN_CR
;
7551 for (tail
= val
; CONSP (tail
); tail
= XCDR (tail
))
7553 enum coding_category category
;
7556 id
= XINT (XCAR (tail
));
7557 attrs
= CODING_ID_ATTRS (id
);
7558 category
= XINT (CODING_ATTR_CATEGORY (attrs
));
7559 eol_type
= CODING_ID_EOL_TYPE (id
);
7560 if (VECTORP (eol_type
))
7562 if (category
== coding_category_utf_16_be
7563 || category
== coding_category_utf_16_be_nosig
)
7564 this_eol
= utf_16_be_eol
;
7565 else if (category
== coding_category_utf_16_le
7566 || category
== coding_category_utf_16_le_nosig
)
7567 this_eol
= utf_16_le_eol
;
7569 this_eol
= normal_eol
;
7571 if (this_eol
== EOL_SEEN_LF
)
7572 XSETCAR (tail
, AREF (eol_type
, 0));
7573 else if (this_eol
== EOL_SEEN_CRLF
)
7574 XSETCAR (tail
, AREF (eol_type
, 1));
7575 else if (this_eol
== EOL_SEEN_CR
)
7576 XSETCAR (tail
, AREF (eol_type
, 2));
7578 XSETCAR (tail
, CODING_ID_NAME (id
));
7581 XSETCAR (tail
, CODING_ID_NAME (id
));
7585 return (highest
? XCAR (val
) : val
);
7589 DEFUN ("detect-coding-region", Fdetect_coding_region
, Sdetect_coding_region
,
7591 doc
: /* Detect coding system of the text in the region between START and END.
7592 Return a list of possible coding systems ordered by priority.
7594 If only ASCII characters are found (except for such ISO-2022 control
7595 characters ISO-2022 as ESC), it returns a list of single element
7596 `undecided' or its subsidiary coding system according to a detected
7599 If optional argument HIGHEST is non-nil, return the coding system of
7600 highest priority. */)
7601 (start
, end
, highest
)
7602 Lisp_Object start
, end
, highest
;
7605 int from_byte
, to_byte
;
7607 CHECK_NUMBER_COERCE_MARKER (start
);
7608 CHECK_NUMBER_COERCE_MARKER (end
);
7610 validate_region (&start
, &end
);
7611 from
= XINT (start
), to
= XINT (end
);
7612 from_byte
= CHAR_TO_BYTE (from
);
7613 to_byte
= CHAR_TO_BYTE (to
);
7615 if (from
< GPT
&& to
>= GPT
)
7616 move_gap_both (to
, to_byte
);
7618 return detect_coding_system (BYTE_POS_ADDR (from_byte
),
7619 to
- from
, to_byte
- from_byte
,
7621 !NILP (current_buffer
7622 ->enable_multibyte_characters
),
7626 DEFUN ("detect-coding-string", Fdetect_coding_string
, Sdetect_coding_string
,
7628 doc
: /* Detect coding system of the text in STRING.
7629 Return a list of possible coding systems ordered by priority.
7631 If only ASCII characters are found (except for such ISO-2022 control
7632 characters ISO-2022 as ESC), it returns a list of single element
7633 `undecided' or its subsidiary coding system according to a detected
7636 If optional argument HIGHEST is non-nil, return the coding system of
7637 highest priority. */)
7639 Lisp_Object string
, highest
;
7641 CHECK_STRING (string
);
7643 return detect_coding_system (SDATA (string
),
7644 SCHARS (string
), SBYTES (string
),
7645 !NILP (highest
), STRING_MULTIBYTE (string
),
7651 char_encodable_p (c
, attrs
)
7656 struct charset
*charset
;
7657 Lisp_Object translation_table
;
7659 translation_table
= CODING_ATTR_TRANS_TBL (attrs
);
7660 if (! NILP (translation_table
))
7661 c
= translate_char (translation_table
, c
);
7662 for (tail
= CODING_ATTR_CHARSET_LIST (attrs
);
7663 CONSP (tail
); tail
= XCDR (tail
))
7665 charset
= CHARSET_FROM_ID (XINT (XCAR (tail
)));
7666 if (CHAR_CHARSET_P (c
, charset
))
7669 return (! NILP (tail
));
7673 /* Return a list of coding systems that safely encode the text between
7674 START and END. If EXCLUDE is non-nil, it is a list of coding
7675 systems not to check. The returned list doesn't contain any such
7676 coding systems. In any case, if the text contains only ASCII or is
7677 unibyte, return t. */
7679 DEFUN ("find-coding-systems-region-internal",
7680 Ffind_coding_systems_region_internal
,
7681 Sfind_coding_systems_region_internal
, 2, 3, 0,
7682 doc
: /* Internal use only. */)
7683 (start
, end
, exclude
)
7684 Lisp_Object start
, end
, exclude
;
7686 Lisp_Object coding_attrs_list
, safe_codings
;
7687 EMACS_INT start_byte
, end_byte
;
7688 const unsigned char *p
, *pbeg
, *pend
;
7690 Lisp_Object tail
, elt
;
7692 if (STRINGP (start
))
7694 if (!STRING_MULTIBYTE (start
)
7695 || SCHARS (start
) == SBYTES (start
))
7698 end_byte
= SBYTES (start
);
7702 CHECK_NUMBER_COERCE_MARKER (start
);
7703 CHECK_NUMBER_COERCE_MARKER (end
);
7704 if (XINT (start
) < BEG
|| XINT (end
) > Z
|| XINT (start
) > XINT (end
))
7705 args_out_of_range (start
, end
);
7706 if (NILP (current_buffer
->enable_multibyte_characters
))
7708 start_byte
= CHAR_TO_BYTE (XINT (start
));
7709 end_byte
= CHAR_TO_BYTE (XINT (end
));
7710 if (XINT (end
) - XINT (start
) == end_byte
- start_byte
)
7713 if (XINT (start
) < GPT
&& XINT (end
) > GPT
)
7715 if ((GPT
- XINT (start
)) < (XINT (end
) - GPT
))
7716 move_gap_both (XINT (start
), start_byte
);
7718 move_gap_both (XINT (end
), end_byte
);
7722 coding_attrs_list
= Qnil
;
7723 for (tail
= Vcoding_system_list
; CONSP (tail
); tail
= XCDR (tail
))
7725 || NILP (Fmemq (XCAR (tail
), exclude
)))
7729 attrs
= AREF (CODING_SYSTEM_SPEC (XCAR (tail
)), 0);
7730 if (EQ (XCAR (tail
), CODING_ATTR_BASE_NAME (attrs
))
7731 && ! EQ (CODING_ATTR_TYPE (attrs
), Qundecided
))
7733 ASET (attrs
, coding_attr_trans_tbl
,
7734 get_translation_table (attrs
, 1, NULL
));
7735 coding_attrs_list
= Fcons (attrs
, coding_attrs_list
);
7739 if (STRINGP (start
))
7740 p
= pbeg
= SDATA (start
);
7742 p
= pbeg
= BYTE_POS_ADDR (start_byte
);
7743 pend
= p
+ (end_byte
- start_byte
);
7745 while (p
< pend
&& ASCII_BYTE_P (*p
)) p
++;
7746 while (p
< pend
&& ASCII_BYTE_P (*(pend
- 1))) pend
--;
7750 if (ASCII_BYTE_P (*p
))
7754 c
= STRING_CHAR_ADVANCE (p
);
7756 charset_map_loaded
= 0;
7757 for (tail
= coding_attrs_list
; CONSP (tail
);)
7762 else if (char_encodable_p (c
, elt
))
7764 else if (CONSP (XCDR (tail
)))
7766 XSETCAR (tail
, XCAR (XCDR (tail
)));
7767 XSETCDR (tail
, XCDR (XCDR (tail
)));
7771 XSETCAR (tail
, Qnil
);
7775 if (charset_map_loaded
)
7777 EMACS_INT p_offset
= p
- pbeg
, pend_offset
= pend
- pbeg
;
7779 if (STRINGP (start
))
7780 pbeg
= SDATA (start
);
7782 pbeg
= BYTE_POS_ADDR (start_byte
);
7783 p
= pbeg
+ p_offset
;
7784 pend
= pbeg
+ pend_offset
;
7789 safe_codings
= list2 (Qraw_text
, Qno_conversion
);
7790 for (tail
= coding_attrs_list
; CONSP (tail
); tail
= XCDR (tail
))
7791 if (! NILP (XCAR (tail
)))
7792 safe_codings
= Fcons (CODING_ATTR_BASE_NAME (XCAR (tail
)), safe_codings
);
7794 return safe_codings
;
7798 DEFUN ("unencodable-char-position", Funencodable_char_position
,
7799 Sunencodable_char_position
, 3, 5, 0,
7801 Return position of first un-encodable character in a region.
7802 START and END specfiy the region and CODING-SYSTEM specifies the
7803 encoding to check. Return nil if CODING-SYSTEM does encode the region.
7805 If optional 4th argument COUNT is non-nil, it specifies at most how
7806 many un-encodable characters to search. In this case, the value is a
7809 If optional 5th argument STRING is non-nil, it is a string to search
7810 for un-encodable characters. In that case, START and END are indexes
7812 (start
, end
, coding_system
, count
, string
)
7813 Lisp_Object start
, end
, coding_system
, count
, string
;
7816 struct coding_system coding
;
7817 Lisp_Object attrs
, charset_list
, translation_table
;
7818 Lisp_Object positions
;
7820 const unsigned char *p
, *stop
, *pend
;
7821 int ascii_compatible
;
7823 setup_coding_system (Fcheck_coding_system (coding_system
), &coding
);
7824 attrs
= CODING_ID_ATTRS (coding
.id
);
7825 if (EQ (CODING_ATTR_TYPE (attrs
), Qraw_text
))
7827 ascii_compatible
= ! NILP (CODING_ATTR_ASCII_COMPAT (attrs
));
7828 charset_list
= CODING_ATTR_CHARSET_LIST (attrs
);
7829 translation_table
= get_translation_table (attrs
, 1, NULL
);
7833 validate_region (&start
, &end
);
7834 from
= XINT (start
);
7836 if (NILP (current_buffer
->enable_multibyte_characters
)
7837 || (ascii_compatible
7838 && (to
- from
) == (CHAR_TO_BYTE (to
) - (CHAR_TO_BYTE (from
)))))
7840 p
= CHAR_POS_ADDR (from
);
7841 pend
= CHAR_POS_ADDR (to
);
7842 if (from
< GPT
&& to
>= GPT
)
7849 CHECK_STRING (string
);
7850 CHECK_NATNUM (start
);
7852 from
= XINT (start
);
7855 || to
> SCHARS (string
))
7856 args_out_of_range_3 (string
, start
, end
);
7857 if (! STRING_MULTIBYTE (string
))
7859 p
= SDATA (string
) + string_char_to_byte (string
, from
);
7860 stop
= pend
= SDATA (string
) + string_char_to_byte (string
, to
);
7861 if (ascii_compatible
&& (to
- from
) == (pend
- p
))
7869 CHECK_NATNUM (count
);
7878 if (ascii_compatible
)
7879 while (p
< stop
&& ASCII_BYTE_P (*p
))
7889 c
= STRING_CHAR_ADVANCE (p
);
7890 if (! (ASCII_CHAR_P (c
) && ascii_compatible
)
7891 && ! char_charset (translate_char (translation_table
, c
),
7892 charset_list
, NULL
))
7894 positions
= Fcons (make_number (from
), positions
);
7903 return (NILP (count
) ? Fcar (positions
) : Fnreverse (positions
));
7907 DEFUN ("check-coding-systems-region", Fcheck_coding_systems_region
,
7908 Scheck_coding_systems_region
, 3, 3, 0,
7909 doc
: /* Check if the region is encodable by coding systems.
7911 START and END are buffer positions specifying the region.
7912 CODING-SYSTEM-LIST is a list of coding systems to check.
7914 The value is an alist ((CODING-SYSTEM POS0 POS1 ...) ...), where
7915 CODING-SYSTEM is a member of CODING-SYSTEM-LIst and can't encode the
7916 whole region, POS0, POS1, ... are buffer positions where non-encodable
7917 characters are found.
7919 If all coding systems in CODING-SYSTEM-LIST can encode the region, the
7922 START may be a string. In that case, check if the string is
7923 encodable, and the value contains indices to the string instead of
7924 buffer positions. END is ignored. */)
7925 (start
, end
, coding_system_list
)
7926 Lisp_Object start
, end
, coding_system_list
;
7929 EMACS_INT start_byte
, end_byte
;
7931 const unsigned char *p
, *pbeg
, *pend
;
7933 Lisp_Object tail
, elt
, attrs
;
7935 if (STRINGP (start
))
7937 if (!STRING_MULTIBYTE (start
)
7938 && SCHARS (start
) != SBYTES (start
))
7941 end_byte
= SBYTES (start
);
7946 CHECK_NUMBER_COERCE_MARKER (start
);
7947 CHECK_NUMBER_COERCE_MARKER (end
);
7948 if (XINT (start
) < BEG
|| XINT (end
) > Z
|| XINT (start
) > XINT (end
))
7949 args_out_of_range (start
, end
);
7950 if (NILP (current_buffer
->enable_multibyte_characters
))
7952 start_byte
= CHAR_TO_BYTE (XINT (start
));
7953 end_byte
= CHAR_TO_BYTE (XINT (end
));
7954 if (XINT (end
) - XINT (start
) == end_byte
- start_byte
)
7957 if (XINT (start
) < GPT
&& XINT (end
) > GPT
)
7959 if ((GPT
- XINT (start
)) < (XINT (end
) - GPT
))
7960 move_gap_both (XINT (start
), start_byte
);
7962 move_gap_both (XINT (end
), end_byte
);
7968 for (tail
= coding_system_list
; CONSP (tail
); tail
= XCDR (tail
))
7971 attrs
= AREF (CODING_SYSTEM_SPEC (elt
), 0);
7972 ASET (attrs
, coding_attr_trans_tbl
,
7973 get_translation_table (attrs
, 1, NULL
));
7974 list
= Fcons (Fcons (elt
, Fcons (attrs
, Qnil
)), list
);
7977 if (STRINGP (start
))
7978 p
= pbeg
= SDATA (start
);
7980 p
= pbeg
= BYTE_POS_ADDR (start_byte
);
7981 pend
= p
+ (end_byte
- start_byte
);
7983 while (p
< pend
&& ASCII_BYTE_P (*p
)) p
++, pos
++;
7984 while (p
< pend
&& ASCII_BYTE_P (*(pend
- 1))) pend
--;
7988 if (ASCII_BYTE_P (*p
))
7992 c
= STRING_CHAR_ADVANCE (p
);
7994 charset_map_loaded
= 0;
7995 for (tail
= list
; CONSP (tail
); tail
= XCDR (tail
))
7997 elt
= XCDR (XCAR (tail
));
7998 if (! char_encodable_p (c
, XCAR (elt
)))
7999 XSETCDR (elt
, Fcons (make_number (pos
), XCDR (elt
)));
8001 if (charset_map_loaded
)
8003 EMACS_INT p_offset
= p
- pbeg
, pend_offset
= pend
- pbeg
;
8005 if (STRINGP (start
))
8006 pbeg
= SDATA (start
);
8008 pbeg
= BYTE_POS_ADDR (start_byte
);
8009 p
= pbeg
+ p_offset
;
8010 pend
= pbeg
+ pend_offset
;
8018 for (; CONSP (tail
); tail
= XCDR (tail
))
8021 if (CONSP (XCDR (XCDR (elt
))))
8022 list
= Fcons (Fcons (XCAR (elt
), Fnreverse (XCDR (XCDR (elt
)))),
8031 code_convert_region (start
, end
, coding_system
, dst_object
, encodep
, norecord
)
8032 Lisp_Object start
, end
, coding_system
, dst_object
;
8033 int encodep
, norecord
;
8035 struct coding_system coding
;
8036 EMACS_INT from
, from_byte
, to
, to_byte
;
8037 Lisp_Object src_object
;
8039 CHECK_NUMBER_COERCE_MARKER (start
);
8040 CHECK_NUMBER_COERCE_MARKER (end
);
8041 if (NILP (coding_system
))
8042 coding_system
= Qno_conversion
;
8044 CHECK_CODING_SYSTEM (coding_system
);
8045 src_object
= Fcurrent_buffer ();
8046 if (NILP (dst_object
))
8047 dst_object
= src_object
;
8048 else if (! EQ (dst_object
, Qt
))
8049 CHECK_BUFFER (dst_object
);
8051 validate_region (&start
, &end
);
8052 from
= XFASTINT (start
);
8053 from_byte
= CHAR_TO_BYTE (from
);
8054 to
= XFASTINT (end
);
8055 to_byte
= CHAR_TO_BYTE (to
);
8057 setup_coding_system (coding_system
, &coding
);
8058 coding
.mode
|= CODING_MODE_LAST_BLOCK
;
8061 encode_coding_object (&coding
, src_object
, from
, from_byte
, to
, to_byte
,
8064 decode_coding_object (&coding
, src_object
, from
, from_byte
, to
, to_byte
,
8067 Vlast_coding_system_used
= CODING_ID_NAME (coding
.id
);
8069 return (BUFFERP (dst_object
)
8070 ? make_number (coding
.produced_char
)
8071 : coding
.dst_object
);
8075 DEFUN ("decode-coding-region", Fdecode_coding_region
, Sdecode_coding_region
,
8076 3, 4, "r\nzCoding system: ",
8077 doc
: /* Decode the current region from the specified coding system.
8078 When called from a program, takes four arguments:
8079 START, END, CODING-SYSTEM, and DESTINATION.
8080 START and END are buffer positions.
8082 Optional 4th arguments DESTINATION specifies where the decoded text goes.
8083 If nil, the region between START and END is replaced by the decoded text.
8084 If buffer, the decoded text is inserted in the buffer.
8085 If t, the decoded text is returned.
8087 This function sets `last-coding-system-used' to the precise coding system
8088 used (which may be different from CODING-SYSTEM if CODING-SYSTEM is
8089 not fully specified.)
8090 It returns the length of the decoded text. */)
8091 (start
, end
, coding_system
, destination
)
8092 Lisp_Object start
, end
, coding_system
, destination
;
8094 return code_convert_region (start
, end
, coding_system
, destination
, 0, 0);
8097 DEFUN ("encode-coding-region", Fencode_coding_region
, Sencode_coding_region
,
8098 3, 4, "r\nzCoding system: ",
8099 doc
: /* Encode the current region by specified coding system.
8100 When called from a program, takes three arguments:
8101 START, END, and CODING-SYSTEM. START and END are buffer positions.
8103 Optional 4th arguments DESTINATION specifies where the encoded text goes.
8104 If nil, the region between START and END is replace by the encoded text.
8105 If buffer, the encoded text is inserted in the buffer.
8106 If t, the encoded text is returned.
8108 This function sets `last-coding-system-used' to the precise coding system
8109 used (which may be different from CODING-SYSTEM if CODING-SYSTEM is
8110 not fully specified.)
8111 It returns the length of the encoded text. */)
8112 (start
, end
, coding_system
, destination
)
8113 Lisp_Object start
, end
, coding_system
, destination
;
8115 return code_convert_region (start
, end
, coding_system
, destination
, 1, 0);
8119 code_convert_string (string
, coding_system
, dst_object
,
8120 encodep
, nocopy
, norecord
)
8121 Lisp_Object string
, coding_system
, dst_object
;
8122 int encodep
, nocopy
, norecord
;
8124 struct coding_system coding
;
8125 EMACS_INT chars
, bytes
;
8127 CHECK_STRING (string
);
8128 if (NILP (coding_system
))
8131 Vlast_coding_system_used
= Qno_conversion
;
8132 if (NILP (dst_object
))
8133 return (nocopy
? Fcopy_sequence (string
) : string
);
8136 if (NILP (coding_system
))
8137 coding_system
= Qno_conversion
;
8139 CHECK_CODING_SYSTEM (coding_system
);
8140 if (NILP (dst_object
))
8142 else if (! EQ (dst_object
, Qt
))
8143 CHECK_BUFFER (dst_object
);
8145 setup_coding_system (coding_system
, &coding
);
8146 coding
.mode
|= CODING_MODE_LAST_BLOCK
;
8147 chars
= SCHARS (string
);
8148 bytes
= SBYTES (string
);
8150 encode_coding_object (&coding
, string
, 0, 0, chars
, bytes
, dst_object
);
8152 decode_coding_object (&coding
, string
, 0, 0, chars
, bytes
, dst_object
);
8154 Vlast_coding_system_used
= CODING_ID_NAME (coding
.id
);
8156 return (BUFFERP (dst_object
)
8157 ? make_number (coding
.produced_char
)
8158 : coding
.dst_object
);
8162 /* Encode or decode STRING according to CODING_SYSTEM.
8163 Do not set Vlast_coding_system_used.
8165 This function is called only from macros DECODE_FILE and
8166 ENCODE_FILE, thus we ignore character composition. */
8169 code_convert_string_norecord (string
, coding_system
, encodep
)
8170 Lisp_Object string
, coding_system
;
8173 return code_convert_string (string
, coding_system
, Qt
, encodep
, 0, 1);
8177 DEFUN ("decode-coding-string", Fdecode_coding_string
, Sdecode_coding_string
,
8179 doc
: /* Decode STRING which is encoded in CODING-SYSTEM, and return the result.
8181 Optional third arg NOCOPY non-nil means it is OK to return STRING itself
8182 if the decoding operation is trivial.
8184 Optional fourth arg BUFFER non-nil meant that the decoded text is
8185 inserted in BUFFER instead of returned as a string. In this case,
8186 the return value is BUFFER.
8188 This function sets `last-coding-system-used' to the precise coding system
8189 used (which may be different from CODING-SYSTEM if CODING-SYSTEM is
8190 not fully specified. */)
8191 (string
, coding_system
, nocopy
, buffer
)
8192 Lisp_Object string
, coding_system
, nocopy
, buffer
;
8194 return code_convert_string (string
, coding_system
, buffer
,
8195 0, ! NILP (nocopy
), 0);
8198 DEFUN ("encode-coding-string", Fencode_coding_string
, Sencode_coding_string
,
8200 doc
: /* Encode STRING to CODING-SYSTEM, and return the result.
8202 Optional third arg NOCOPY non-nil means it is OK to return STRING
8203 itself if the encoding operation is trivial.
8205 Optional fourth arg BUFFER non-nil meant that the encoded text is
8206 inserted in BUFFER instead of returned as a string. In this case,
8207 the return value is BUFFER.
8209 This function sets `last-coding-system-used' to the precise coding system
8210 used (which may be different from CODING-SYSTEM if CODING-SYSTEM is
8211 not fully specified.) */)
8212 (string
, coding_system
, nocopy
, buffer
)
8213 Lisp_Object string
, coding_system
, nocopy
, buffer
;
8215 return code_convert_string (string
, coding_system
, buffer
,
8216 1, ! NILP (nocopy
), 1);
8220 DEFUN ("decode-sjis-char", Fdecode_sjis_char
, Sdecode_sjis_char
, 1, 1, 0,
8221 doc
: /* Decode a Japanese character which has CODE in shift_jis encoding.
8222 Return the corresponding character. */)
8226 Lisp_Object spec
, attrs
, val
;
8227 struct charset
*charset_roman
, *charset_kanji
, *charset_kana
, *charset
;
8230 CHECK_NATNUM (code
);
8231 c
= XFASTINT (code
);
8232 CHECK_CODING_SYSTEM_GET_SPEC (Vsjis_coding_system
, spec
);
8233 attrs
= AREF (spec
, 0);
8235 if (ASCII_BYTE_P (c
)
8236 && ! NILP (CODING_ATTR_ASCII_COMPAT (attrs
)))
8239 val
= CODING_ATTR_CHARSET_LIST (attrs
);
8240 charset_roman
= CHARSET_FROM_ID (XINT (XCAR (val
))), val
= XCDR (val
);
8241 charset_kana
= CHARSET_FROM_ID (XINT (XCAR (val
))), val
= XCDR (val
);
8242 charset_kanji
= CHARSET_FROM_ID (XINT (XCAR (val
)));
8245 charset
= charset_roman
;
8246 else if (c
>= 0xA0 && c
< 0xDF)
8248 charset
= charset_kana
;
8253 int s1
= c
>> 8, s2
= c
& 0xFF;
8255 if (s1
< 0x81 || (s1
> 0x9F && s1
< 0xE0) || s1
> 0xEF
8256 || s2
< 0x40 || s2
== 0x7F || s2
> 0xFC)
8257 error ("Invalid code: %d", code
);
8259 charset
= charset_kanji
;
8261 c
= DECODE_CHAR (charset
, c
);
8263 error ("Invalid code: %d", code
);
8264 return make_number (c
);
8268 DEFUN ("encode-sjis-char", Fencode_sjis_char
, Sencode_sjis_char
, 1, 1, 0,
8269 doc
: /* Encode a Japanese character CH to shift_jis encoding.
8270 Return the corresponding code in SJIS. */)
8274 Lisp_Object spec
, attrs
, charset_list
;
8276 struct charset
*charset
;
8279 CHECK_CHARACTER (ch
);
8281 CHECK_CODING_SYSTEM_GET_SPEC (Vsjis_coding_system
, spec
);
8282 attrs
= AREF (spec
, 0);
8284 if (ASCII_CHAR_P (c
)
8285 && ! NILP (CODING_ATTR_ASCII_COMPAT (attrs
)))
8288 charset_list
= CODING_ATTR_CHARSET_LIST (attrs
);
8289 charset
= char_charset (c
, charset_list
, &code
);
8290 if (code
== CHARSET_INVALID_CODE (charset
))
8291 error ("Can't encode by shift_jis encoding: %d", c
);
8294 return make_number (code
);
8297 DEFUN ("decode-big5-char", Fdecode_big5_char
, Sdecode_big5_char
, 1, 1, 0,
8298 doc
: /* Decode a Big5 character which has CODE in BIG5 coding system.
8299 Return the corresponding character. */)
8303 Lisp_Object spec
, attrs
, val
;
8304 struct charset
*charset_roman
, *charset_big5
, *charset
;
8307 CHECK_NATNUM (code
);
8308 c
= XFASTINT (code
);
8309 CHECK_CODING_SYSTEM_GET_SPEC (Vbig5_coding_system
, spec
);
8310 attrs
= AREF (spec
, 0);
8312 if (ASCII_BYTE_P (c
)
8313 && ! NILP (CODING_ATTR_ASCII_COMPAT (attrs
)))
8316 val
= CODING_ATTR_CHARSET_LIST (attrs
);
8317 charset_roman
= CHARSET_FROM_ID (XINT (XCAR (val
))), val
= XCDR (val
);
8318 charset_big5
= CHARSET_FROM_ID (XINT (XCAR (val
)));
8321 charset
= charset_roman
;
8324 int b1
= c
>> 8, b2
= c
& 0x7F;
8325 if (b1
< 0xA1 || b1
> 0xFE
8326 || b2
< 0x40 || (b2
> 0x7E && b2
< 0xA1) || b2
> 0xFE)
8327 error ("Invalid code: %d", code
);
8328 charset
= charset_big5
;
8330 c
= DECODE_CHAR (charset
, (unsigned )c
);
8332 error ("Invalid code: %d", code
);
8333 return make_number (c
);
8336 DEFUN ("encode-big5-char", Fencode_big5_char
, Sencode_big5_char
, 1, 1, 0,
8337 doc
: /* Encode the Big5 character CH to BIG5 coding system.
8338 Return the corresponding character code in Big5. */)
8342 Lisp_Object spec
, attrs
, charset_list
;
8343 struct charset
*charset
;
8347 CHECK_CHARACTER (ch
);
8349 CHECK_CODING_SYSTEM_GET_SPEC (Vbig5_coding_system
, spec
);
8350 attrs
= AREF (spec
, 0);
8351 if (ASCII_CHAR_P (c
)
8352 && ! NILP (CODING_ATTR_ASCII_COMPAT (attrs
)))
8355 charset_list
= CODING_ATTR_CHARSET_LIST (attrs
);
8356 charset
= char_charset (c
, charset_list
, &code
);
8357 if (code
== CHARSET_INVALID_CODE (charset
))
8358 error ("Can't encode by Big5 encoding: %d", c
);
8360 return make_number (code
);
8364 DEFUN ("set-terminal-coding-system-internal", Fset_terminal_coding_system_internal
,
8365 Sset_terminal_coding_system_internal
, 1, 2, 0,
8366 doc
: /* Internal use only. */)
8367 (coding_system
, terminal
)
8368 Lisp_Object coding_system
;
8369 Lisp_Object terminal
;
8371 struct coding_system
*terminal_coding
= TERMINAL_TERMINAL_CODING (get_terminal (terminal
, 1));
8372 CHECK_SYMBOL (coding_system
);
8373 setup_coding_system (Fcheck_coding_system (coding_system
), terminal_coding
);
8374 /* We had better not send unsafe characters to terminal. */
8375 terminal_coding
->mode
|= CODING_MODE_SAFE_ENCODING
;
8376 /* Characer composition should be disabled. */
8377 terminal_coding
->common_flags
&= ~CODING_ANNOTATE_COMPOSITION_MASK
;
8378 terminal_coding
->src_multibyte
= 1;
8379 terminal_coding
->dst_multibyte
= 0;
8383 DEFUN ("set-safe-terminal-coding-system-internal",
8384 Fset_safe_terminal_coding_system_internal
,
8385 Sset_safe_terminal_coding_system_internal
, 1, 1, 0,
8386 doc
: /* Internal use only. */)
8388 Lisp_Object coding_system
;
8390 CHECK_SYMBOL (coding_system
);
8391 setup_coding_system (Fcheck_coding_system (coding_system
),
8392 &safe_terminal_coding
);
8393 /* Characer composition should be disabled. */
8394 safe_terminal_coding
.common_flags
&= ~CODING_ANNOTATE_COMPOSITION_MASK
;
8395 safe_terminal_coding
.src_multibyte
= 1;
8396 safe_terminal_coding
.dst_multibyte
= 0;
8400 DEFUN ("terminal-coding-system", Fterminal_coding_system
,
8401 Sterminal_coding_system
, 0, 1, 0,
8402 doc
: /* Return coding system specified for terminal output on the given terminal.
8403 TERMINAL may be a terminal id, a frame, or nil for the selected
8404 frame's terminal device. */)
8406 Lisp_Object terminal
;
8408 struct coding_system
*terminal_coding
8409 = TERMINAL_TERMINAL_CODING (get_terminal (terminal
, 1));
8410 Lisp_Object coding_system
= CODING_ID_NAME (terminal_coding
->id
);
8412 /* For backward compatibility, return nil if it is `undecided'. */
8413 return (! EQ (coding_system
, Qundecided
) ? coding_system
: Qnil
);
8416 DEFUN ("set-keyboard-coding-system-internal", Fset_keyboard_coding_system_internal
,
8417 Sset_keyboard_coding_system_internal
, 1, 2, 0,
8418 doc
: /* Internal use only. */)
8419 (coding_system
, terminal
)
8420 Lisp_Object coding_system
;
8421 Lisp_Object terminal
;
8423 struct terminal
*t
= get_terminal (terminal
, 1);
8424 CHECK_SYMBOL (coding_system
);
8425 setup_coding_system (Fcheck_coding_system (coding_system
),
8426 TERMINAL_KEYBOARD_CODING (t
));
8427 /* Characer composition should be disabled. */
8428 TERMINAL_KEYBOARD_CODING (t
)->common_flags
8429 &= ~CODING_ANNOTATE_COMPOSITION_MASK
;
8433 DEFUN ("keyboard-coding-system",
8434 Fkeyboard_coding_system
, Skeyboard_coding_system
, 0, 1, 0,
8435 doc
: /* Return coding system specified for decoding keyboard input. */)
8437 Lisp_Object terminal
;
8439 return CODING_ID_NAME (TERMINAL_KEYBOARD_CODING
8440 (get_terminal (terminal
, 1))->id
);
8444 DEFUN ("find-operation-coding-system", Ffind_operation_coding_system
,
8445 Sfind_operation_coding_system
, 1, MANY
, 0,
8446 doc
: /* Choose a coding system for an operation based on the target name.
8447 The value names a pair of coding systems: (DECODING-SYSTEM . ENCODING-SYSTEM).
8448 DECODING-SYSTEM is the coding system to use for decoding
8449 \(in case OPERATION does decoding), and ENCODING-SYSTEM is the coding system
8450 for encoding (in case OPERATION does encoding).
8452 The first argument OPERATION specifies an I/O primitive:
8453 For file I/O, `insert-file-contents' or `write-region'.
8454 For process I/O, `call-process', `call-process-region', or `start-process'.
8455 For network I/O, `open-network-stream'.
8457 The remaining arguments should be the same arguments that were passed
8458 to the primitive. Depending on which primitive, one of those arguments
8459 is selected as the TARGET. For example, if OPERATION does file I/O,
8460 whichever argument specifies the file name is TARGET.
8462 TARGET has a meaning which depends on OPERATION:
8463 For file I/O, TARGET is a file name (except for the special case below).
8464 For process I/O, TARGET is a process name.
8465 For network I/O, TARGET is a service name or a port number
8467 This function looks up what specified for TARGET in,
8468 `file-coding-system-alist', `process-coding-system-alist',
8469 or `network-coding-system-alist' depending on OPERATION.
8470 They may specify a coding system, a cons of coding systems,
8471 or a function symbol to call.
8472 In the last case, we call the function with one argument,
8473 which is a list of all the arguments given to this function.
8474 If the function can't decide a coding system, it can return
8475 `undecided' so that the normal code-detection is performed.
8477 If OPERATION is `insert-file-contents', the argument corresponding to
8478 TARGET may be a cons (FILENAME . BUFFER). In that case, FILENAME is a
8479 file name to look up, and BUFFER is a buffer that contains the file's
8480 contents (not yet decoded). If `file-coding-system-alist' specifies a
8481 function to call for FILENAME, that function should examine the
8482 contents of BUFFER instead of reading the file.
8484 usage: (find-operation-coding-system OPERATION ARGUMENTS...) */)
8489 Lisp_Object operation
, target_idx
, target
, val
;
8490 register Lisp_Object chain
;
8493 error ("Too few arguments");
8494 operation
= args
[0];
8495 if (!SYMBOLP (operation
)
8496 || !INTEGERP (target_idx
= Fget (operation
, Qtarget_idx
)))
8497 error ("Invalid first arguement");
8498 if (nargs
< 1 + XINT (target_idx
))
8499 error ("Too few arguments for operation: %s",
8500 SDATA (SYMBOL_NAME (operation
)));
8501 target
= args
[XINT (target_idx
) + 1];
8502 if (!(STRINGP (target
)
8503 || (EQ (operation
, Qinsert_file_contents
) && CONSP (target
)
8504 && STRINGP (XCAR (target
)) && BUFFERP (XCDR (target
)))
8505 || (EQ (operation
, Qopen_network_stream
) && INTEGERP (target
))))
8506 error ("Invalid %dth argument", XINT (target_idx
) + 1);
8508 target
= XCAR (target
);
8510 chain
= ((EQ (operation
, Qinsert_file_contents
)
8511 || EQ (operation
, Qwrite_region
))
8512 ? Vfile_coding_system_alist
8513 : (EQ (operation
, Qopen_network_stream
)
8514 ? Vnetwork_coding_system_alist
8515 : Vprocess_coding_system_alist
));
8519 for (; CONSP (chain
); chain
= XCDR (chain
))
8525 && ((STRINGP (target
)
8526 && STRINGP (XCAR (elt
))
8527 && fast_string_match (XCAR (elt
), target
) >= 0)
8528 || (INTEGERP (target
) && EQ (target
, XCAR (elt
)))))
8531 /* Here, if VAL is both a valid coding system and a valid
8532 function symbol, we return VAL as a coding system. */
8535 if (! SYMBOLP (val
))
8537 if (! NILP (Fcoding_system_p (val
)))
8538 return Fcons (val
, val
);
8539 if (! NILP (Ffboundp (val
)))
8541 /* We use call1 rather than safe_call1
8542 so as to get bug reports about functions called here
8543 which don't handle the current interface. */
8544 val
= call1 (val
, Flist (nargs
, args
));
8547 if (SYMBOLP (val
) && ! NILP (Fcoding_system_p (val
)))
8548 return Fcons (val
, val
);
8556 DEFUN ("set-coding-system-priority", Fset_coding_system_priority
,
8557 Sset_coding_system_priority
, 0, MANY
, 0,
8558 doc
: /* Assign higher priority to the coding systems given as arguments.
8559 If multiple coding systems belongs to the same category,
8560 all but the first one are ignored.
8562 usage: (set-coding-system-priority ...) */)
8568 int changed
[coding_category_max
];
8569 enum coding_category priorities
[coding_category_max
];
8571 bzero (changed
, sizeof changed
);
8573 for (i
= j
= 0; i
< nargs
; i
++)
8575 enum coding_category category
;
8576 Lisp_Object spec
, attrs
;
8578 CHECK_CODING_SYSTEM_GET_SPEC (args
[i
], spec
);
8579 attrs
= AREF (spec
, 0);
8580 category
= XINT (CODING_ATTR_CATEGORY (attrs
));
8581 if (changed
[category
])
8582 /* Ignore this coding system because a coding system of the
8583 same category already had a higher priority. */
8585 changed
[category
] = 1;
8586 priorities
[j
++] = category
;
8587 if (coding_categories
[category
].id
>= 0
8588 && ! EQ (args
[i
], CODING_ID_NAME (coding_categories
[category
].id
)))
8589 setup_coding_system (args
[i
], &coding_categories
[category
]);
8590 Fset (AREF (Vcoding_category_table
, category
), args
[i
]);
8593 /* Now we have decided top J priorities. Reflect the order of the
8594 original priorities to the remaining priorities. */
8596 for (i
= j
, j
= 0; i
< coding_category_max
; i
++, j
++)
8598 while (j
< coding_category_max
8599 && changed
[coding_priorities
[j
]])
8601 if (j
== coding_category_max
)
8603 priorities
[i
] = coding_priorities
[j
];
8606 bcopy (priorities
, coding_priorities
, sizeof priorities
);
8608 /* Update `coding-category-list'. */
8609 Vcoding_category_list
= Qnil
;
8610 for (i
= coding_category_max
- 1; i
>= 0; i
--)
8611 Vcoding_category_list
8612 = Fcons (AREF (Vcoding_category_table
, priorities
[i
]),
8613 Vcoding_category_list
);
8618 DEFUN ("coding-system-priority-list", Fcoding_system_priority_list
,
8619 Scoding_system_priority_list
, 0, 1, 0,
8620 doc
: /* Return a list of coding systems ordered by their priorities.
8621 HIGHESTP non-nil means just return the highest priority one. */)
8623 Lisp_Object highestp
;
8628 for (i
= 0, val
= Qnil
; i
< coding_category_max
; i
++)
8630 enum coding_category category
= coding_priorities
[i
];
8631 int id
= coding_categories
[category
].id
;
8636 attrs
= CODING_ID_ATTRS (id
);
8637 if (! NILP (highestp
))
8638 return CODING_ATTR_BASE_NAME (attrs
);
8639 val
= Fcons (CODING_ATTR_BASE_NAME (attrs
), val
);
8641 return Fnreverse (val
);
8644 static char *suffixes
[] = { "-unix", "-dos", "-mac" };
8647 make_subsidiaries (base
)
8650 Lisp_Object subsidiaries
;
8651 int base_name_len
= SBYTES (SYMBOL_NAME (base
));
8652 char *buf
= (char *) alloca (base_name_len
+ 6);
8655 bcopy (SDATA (SYMBOL_NAME (base
)), buf
, base_name_len
);
8656 subsidiaries
= Fmake_vector (make_number (3), Qnil
);
8657 for (i
= 0; i
< 3; i
++)
8659 bcopy (suffixes
[i
], buf
+ base_name_len
, strlen (suffixes
[i
]) + 1);
8660 ASET (subsidiaries
, i
, intern (buf
));
8662 return subsidiaries
;
8666 DEFUN ("define-coding-system-internal", Fdefine_coding_system_internal
,
8667 Sdefine_coding_system_internal
, coding_arg_max
, MANY
, 0,
8668 doc
: /* For internal use only.
8669 usage: (define-coding-system-internal ...) */)
8675 Lisp_Object spec_vec
; /* [ ATTRS ALIASE EOL_TYPE ] */
8676 Lisp_Object attrs
; /* Vector of attributes. */
8677 Lisp_Object eol_type
;
8678 Lisp_Object aliases
;
8679 Lisp_Object coding_type
, charset_list
, safe_charsets
;
8680 enum coding_category category
;
8681 Lisp_Object tail
, val
;
8682 int max_charset_id
= 0;
8685 if (nargs
< coding_arg_max
)
8688 attrs
= Fmake_vector (make_number (coding_attr_last_index
), Qnil
);
8690 name
= args
[coding_arg_name
];
8691 CHECK_SYMBOL (name
);
8692 CODING_ATTR_BASE_NAME (attrs
) = name
;
8694 val
= args
[coding_arg_mnemonic
];
8695 if (! STRINGP (val
))
8696 CHECK_CHARACTER (val
);
8697 CODING_ATTR_MNEMONIC (attrs
) = val
;
8699 coding_type
= args
[coding_arg_coding_type
];
8700 CHECK_SYMBOL (coding_type
);
8701 CODING_ATTR_TYPE (attrs
) = coding_type
;
8703 charset_list
= args
[coding_arg_charset_list
];
8704 if (SYMBOLP (charset_list
))
8706 if (EQ (charset_list
, Qiso_2022
))
8708 if (! EQ (coding_type
, Qiso_2022
))
8709 error ("Invalid charset-list");
8710 charset_list
= Viso_2022_charset_list
;
8712 else if (EQ (charset_list
, Qemacs_mule
))
8714 if (! EQ (coding_type
, Qemacs_mule
))
8715 error ("Invalid charset-list");
8716 charset_list
= Vemacs_mule_charset_list
;
8718 for (tail
= charset_list
; CONSP (tail
); tail
= XCDR (tail
))
8719 if (max_charset_id
< XFASTINT (XCAR (tail
)))
8720 max_charset_id
= XFASTINT (XCAR (tail
));
8724 charset_list
= Fcopy_sequence (charset_list
);
8725 for (tail
= charset_list
; CONSP (tail
); tail
= XCDR (tail
))
8727 struct charset
*charset
;
8730 CHECK_CHARSET_GET_CHARSET (val
, charset
);
8731 if (EQ (coding_type
, Qiso_2022
)
8732 ? CHARSET_ISO_FINAL (charset
) < 0
8733 : EQ (coding_type
, Qemacs_mule
)
8734 ? CHARSET_EMACS_MULE_ID (charset
) < 0
8736 error ("Can't handle charset `%s'",
8737 SDATA (SYMBOL_NAME (CHARSET_NAME (charset
))));
8739 XSETCAR (tail
, make_number (charset
->id
));
8740 if (max_charset_id
< charset
->id
)
8741 max_charset_id
= charset
->id
;
8744 CODING_ATTR_CHARSET_LIST (attrs
) = charset_list
;
8746 safe_charsets
= Fmake_string (make_number (max_charset_id
+ 1),
8748 for (tail
= charset_list
; CONSP (tail
); tail
= XCDR (tail
))
8749 SSET (safe_charsets
, XFASTINT (XCAR (tail
)), 0);
8750 CODING_ATTR_SAFE_CHARSETS (attrs
) = safe_charsets
;
8752 CODING_ATTR_ASCII_COMPAT (attrs
) = args
[coding_arg_ascii_compatible_p
];
8754 val
= args
[coding_arg_decode_translation_table
];
8755 if (! CHAR_TABLE_P (val
) && ! CONSP (val
))
8757 CODING_ATTR_DECODE_TBL (attrs
) = val
;
8759 val
= args
[coding_arg_encode_translation_table
];
8760 if (! CHAR_TABLE_P (val
) && ! CONSP (val
))
8762 CODING_ATTR_ENCODE_TBL (attrs
) = val
;
8764 val
= args
[coding_arg_post_read_conversion
];
8766 CODING_ATTR_POST_READ (attrs
) = val
;
8768 val
= args
[coding_arg_pre_write_conversion
];
8770 CODING_ATTR_PRE_WRITE (attrs
) = val
;
8772 val
= args
[coding_arg_default_char
];
8774 CODING_ATTR_DEFAULT_CHAR (attrs
) = make_number (' ');
8777 CHECK_CHARACTER (val
);
8778 CODING_ATTR_DEFAULT_CHAR (attrs
) = val
;
8781 val
= args
[coding_arg_for_unibyte
];
8782 CODING_ATTR_FOR_UNIBYTE (attrs
) = NILP (val
) ? Qnil
: Qt
;
8784 val
= args
[coding_arg_plist
];
8786 CODING_ATTR_PLIST (attrs
) = val
;
8788 if (EQ (coding_type
, Qcharset
))
8790 /* Generate a lisp vector of 256 elements. Each element is nil,
8791 integer, or a list of charset IDs.
8793 If Nth element is nil, the byte code N is invalid in this
8796 If Nth element is a number NUM, N is the first byte of a
8797 charset whose ID is NUM.
8799 If Nth element is a list of charset IDs, N is the first byte
8800 of one of them. The list is sorted by dimensions of the
8801 charsets. A charset of smaller dimension comes firtst. */
8802 val
= Fmake_vector (make_number (256), Qnil
);
8804 for (tail
= charset_list
; CONSP (tail
); tail
= XCDR (tail
))
8806 struct charset
*charset
= CHARSET_FROM_ID (XFASTINT (XCAR (tail
)));
8807 int dim
= CHARSET_DIMENSION (charset
);
8808 int idx
= (dim
- 1) * 4;
8810 if (CHARSET_ASCII_COMPATIBLE_P (charset
))
8811 CODING_ATTR_ASCII_COMPAT (attrs
) = Qt
;
8813 for (i
= charset
->code_space
[idx
];
8814 i
<= charset
->code_space
[idx
+ 1]; i
++)
8816 Lisp_Object tmp
, tmp2
;
8819 tmp
= AREF (val
, i
);
8822 else if (NUMBERP (tmp
))
8824 dim2
= CHARSET_DIMENSION (CHARSET_FROM_ID (XFASTINT (tmp
)));
8826 tmp
= Fcons (XCAR (tail
), Fcons (tmp
, Qnil
));
8828 tmp
= Fcons (tmp
, Fcons (XCAR (tail
), Qnil
));
8832 for (tmp2
= tmp
; CONSP (tmp2
); tmp2
= XCDR (tmp2
))
8834 dim2
= CHARSET_DIMENSION (CHARSET_FROM_ID (XFASTINT (XCAR (tmp2
))));
8839 tmp
= nconc2 (tmp
, Fcons (XCAR (tail
), Qnil
));
8842 XSETCDR (tmp2
, Fcons (XCAR (tmp2
), XCDR (tmp2
)));
8843 XSETCAR (tmp2
, XCAR (tail
));
8849 ASET (attrs
, coding_attr_charset_valids
, val
);
8850 category
= coding_category_charset
;
8852 else if (EQ (coding_type
, Qccl
))
8856 if (nargs
< coding_arg_ccl_max
)
8859 val
= args
[coding_arg_ccl_decoder
];
8860 CHECK_CCL_PROGRAM (val
);
8862 val
= Fcopy_sequence (val
);
8863 ASET (attrs
, coding_attr_ccl_decoder
, val
);
8865 val
= args
[coding_arg_ccl_encoder
];
8866 CHECK_CCL_PROGRAM (val
);
8868 val
= Fcopy_sequence (val
);
8869 ASET (attrs
, coding_attr_ccl_encoder
, val
);
8871 val
= args
[coding_arg_ccl_valids
];
8872 valids
= Fmake_string (make_number (256), make_number (0));
8873 for (tail
= val
; !NILP (tail
); tail
= Fcdr (tail
))
8880 from
= to
= XINT (val
);
8881 if (from
< 0 || from
> 255)
8882 args_out_of_range_3 (val
, make_number (0), make_number (255));
8887 CHECK_NATNUM_CAR (val
);
8888 CHECK_NATNUM_CDR (val
);
8889 from
= XINT (XCAR (val
));
8891 args_out_of_range_3 (XCAR (val
),
8892 make_number (0), make_number (255));
8893 to
= XINT (XCDR (val
));
8894 if (to
< from
|| to
> 255)
8895 args_out_of_range_3 (XCDR (val
),
8896 XCAR (val
), make_number (255));
8898 for (i
= from
; i
<= to
; i
++)
8899 SSET (valids
, i
, 1);
8901 ASET (attrs
, coding_attr_ccl_valids
, valids
);
8903 category
= coding_category_ccl
;
8905 else if (EQ (coding_type
, Qutf_16
))
8907 Lisp_Object bom
, endian
;
8909 CODING_ATTR_ASCII_COMPAT (attrs
) = Qnil
;
8911 if (nargs
< coding_arg_utf16_max
)
8914 bom
= args
[coding_arg_utf16_bom
];
8915 if (! NILP (bom
) && ! EQ (bom
, Qt
))
8919 CHECK_CODING_SYSTEM (val
);
8921 CHECK_CODING_SYSTEM (val
);
8923 ASET (attrs
, coding_attr_utf_16_bom
, bom
);
8925 endian
= args
[coding_arg_utf16_endian
];
8926 CHECK_SYMBOL (endian
);
8929 else if (! EQ (endian
, Qbig
) && ! EQ (endian
, Qlittle
))
8930 error ("Invalid endian: %s", SDATA (SYMBOL_NAME (endian
)));
8931 ASET (attrs
, coding_attr_utf_16_endian
, endian
);
8933 category
= (CONSP (bom
)
8934 ? coding_category_utf_16_auto
8936 ? (EQ (endian
, Qbig
)
8937 ? coding_category_utf_16_be_nosig
8938 : coding_category_utf_16_le_nosig
)
8939 : (EQ (endian
, Qbig
)
8940 ? coding_category_utf_16_be
8941 : coding_category_utf_16_le
));
8943 else if (EQ (coding_type
, Qiso_2022
))
8945 Lisp_Object initial
, reg_usage
, request
, flags
;
8948 if (nargs
< coding_arg_iso2022_max
)
8951 initial
= Fcopy_sequence (args
[coding_arg_iso2022_initial
]);
8952 CHECK_VECTOR (initial
);
8953 for (i
= 0; i
< 4; i
++)
8955 val
= Faref (initial
, make_number (i
));
8958 struct charset
*charset
;
8960 CHECK_CHARSET_GET_CHARSET (val
, charset
);
8961 ASET (initial
, i
, make_number (CHARSET_ID (charset
)));
8962 if (i
== 0 && CHARSET_ASCII_COMPATIBLE_P (charset
))
8963 CODING_ATTR_ASCII_COMPAT (attrs
) = Qt
;
8966 ASET (initial
, i
, make_number (-1));
8969 reg_usage
= args
[coding_arg_iso2022_reg_usage
];
8970 CHECK_CONS (reg_usage
);
8971 CHECK_NUMBER_CAR (reg_usage
);
8972 CHECK_NUMBER_CDR (reg_usage
);
8974 request
= Fcopy_sequence (args
[coding_arg_iso2022_request
]);
8975 for (tail
= request
; ! NILP (tail
); tail
= Fcdr (tail
))
8983 CHECK_CHARSET_GET_ID (tmp
, id
);
8984 CHECK_NATNUM_CDR (val
);
8985 if (XINT (XCDR (val
)) >= 4)
8986 error ("Invalid graphic register number: %d", XINT (XCDR (val
)));
8987 XSETCAR (val
, make_number (id
));
8990 flags
= args
[coding_arg_iso2022_flags
];
8991 CHECK_NATNUM (flags
);
8993 if (EQ (args
[coding_arg_charset_list
], Qiso_2022
))
8994 flags
= make_number (i
| CODING_ISO_FLAG_FULL_SUPPORT
);
8996 ASET (attrs
, coding_attr_iso_initial
, initial
);
8997 ASET (attrs
, coding_attr_iso_usage
, reg_usage
);
8998 ASET (attrs
, coding_attr_iso_request
, request
);
8999 ASET (attrs
, coding_attr_iso_flags
, flags
);
9000 setup_iso_safe_charsets (attrs
);
9002 if (i
& CODING_ISO_FLAG_SEVEN_BITS
)
9003 category
= ((i
& (CODING_ISO_FLAG_LOCKING_SHIFT
9004 | CODING_ISO_FLAG_SINGLE_SHIFT
))
9005 ? coding_category_iso_7_else
9006 : EQ (args
[coding_arg_charset_list
], Qiso_2022
)
9007 ? coding_category_iso_7
9008 : coding_category_iso_7_tight
);
9011 int id
= XINT (AREF (initial
, 1));
9013 category
= (((i
& CODING_ISO_FLAG_LOCKING_SHIFT
)
9014 || EQ (args
[coding_arg_charset_list
], Qiso_2022
)
9016 ? coding_category_iso_8_else
9017 : (CHARSET_DIMENSION (CHARSET_FROM_ID (id
)) == 1)
9018 ? coding_category_iso_8_1
9019 : coding_category_iso_8_2
);
9021 if (category
!= coding_category_iso_8_1
9022 && category
!= coding_category_iso_8_2
)
9023 CODING_ATTR_ASCII_COMPAT (attrs
) = Qnil
;
9025 else if (EQ (coding_type
, Qemacs_mule
))
9027 if (EQ (args
[coding_arg_charset_list
], Qemacs_mule
))
9028 ASET (attrs
, coding_attr_emacs_mule_full
, Qt
);
9029 CODING_ATTR_ASCII_COMPAT (attrs
) = Qt
;
9030 category
= coding_category_emacs_mule
;
9032 else if (EQ (coding_type
, Qshift_jis
))
9035 struct charset
*charset
;
9037 if (XINT (Flength (charset_list
)) != 3
9038 && XINT (Flength (charset_list
)) != 4)
9039 error ("There should be three or four charsets");
9041 charset
= CHARSET_FROM_ID (XINT (XCAR (charset_list
)));
9042 if (CHARSET_DIMENSION (charset
) != 1)
9043 error ("Dimension of charset %s is not one",
9044 SDATA (SYMBOL_NAME (CHARSET_NAME (charset
))));
9045 if (CHARSET_ASCII_COMPATIBLE_P (charset
))
9046 CODING_ATTR_ASCII_COMPAT (attrs
) = Qt
;
9048 charset_list
= XCDR (charset_list
);
9049 charset
= CHARSET_FROM_ID (XINT (XCAR (charset_list
)));
9050 if (CHARSET_DIMENSION (charset
) != 1)
9051 error ("Dimension of charset %s is not one",
9052 SDATA (SYMBOL_NAME (CHARSET_NAME (charset
))));
9054 charset_list
= XCDR (charset_list
);
9055 charset
= CHARSET_FROM_ID (XINT (XCAR (charset_list
)));
9056 if (CHARSET_DIMENSION (charset
) != 2)
9057 error ("Dimension of charset %s is not two",
9058 SDATA (SYMBOL_NAME (CHARSET_NAME (charset
))));
9060 charset_list
= XCDR (charset_list
);
9061 if (! NILP (charset_list
))
9063 charset
= CHARSET_FROM_ID (XINT (XCAR (charset_list
)));
9064 if (CHARSET_DIMENSION (charset
) != 2)
9065 error ("Dimension of charset %s is not two",
9066 SDATA (SYMBOL_NAME (CHARSET_NAME (charset
))));
9069 category
= coding_category_sjis
;
9070 Vsjis_coding_system
= name
;
9072 else if (EQ (coding_type
, Qbig5
))
9074 struct charset
*charset
;
9076 if (XINT (Flength (charset_list
)) != 2)
9077 error ("There should be just two charsets");
9079 charset
= CHARSET_FROM_ID (XINT (XCAR (charset_list
)));
9080 if (CHARSET_DIMENSION (charset
) != 1)
9081 error ("Dimension of charset %s is not one",
9082 SDATA (SYMBOL_NAME (CHARSET_NAME (charset
))));
9083 if (CHARSET_ASCII_COMPATIBLE_P (charset
))
9084 CODING_ATTR_ASCII_COMPAT (attrs
) = Qt
;
9086 charset_list
= XCDR (charset_list
);
9087 charset
= CHARSET_FROM_ID (XINT (XCAR (charset_list
)));
9088 if (CHARSET_DIMENSION (charset
) != 2)
9089 error ("Dimension of charset %s is not two",
9090 SDATA (SYMBOL_NAME (CHARSET_NAME (charset
))));
9092 category
= coding_category_big5
;
9093 Vbig5_coding_system
= name
;
9095 else if (EQ (coding_type
, Qraw_text
))
9097 category
= coding_category_raw_text
;
9098 CODING_ATTR_ASCII_COMPAT (attrs
) = Qt
;
9100 else if (EQ (coding_type
, Qutf_8
))
9102 category
= coding_category_utf_8
;
9103 CODING_ATTR_ASCII_COMPAT (attrs
) = Qt
;
9105 else if (EQ (coding_type
, Qundecided
))
9106 category
= coding_category_undecided
;
9108 error ("Invalid coding system type: %s",
9109 SDATA (SYMBOL_NAME (coding_type
)));
9111 CODING_ATTR_CATEGORY (attrs
) = make_number (category
);
9112 CODING_ATTR_PLIST (attrs
)
9113 = Fcons (QCcategory
, Fcons (AREF (Vcoding_category_table
, category
),
9114 CODING_ATTR_PLIST (attrs
)));
9115 CODING_ATTR_PLIST (attrs
)
9116 = Fcons (QCascii_compatible_p
,
9117 Fcons (CODING_ATTR_ASCII_COMPAT (attrs
),
9118 CODING_ATTR_PLIST (attrs
)));
9120 eol_type
= args
[coding_arg_eol_type
];
9121 if (! NILP (eol_type
)
9122 && ! EQ (eol_type
, Qunix
)
9123 && ! EQ (eol_type
, Qdos
)
9124 && ! EQ (eol_type
, Qmac
))
9125 error ("Invalid eol-type");
9127 aliases
= Fcons (name
, Qnil
);
9129 if (NILP (eol_type
))
9131 eol_type
= make_subsidiaries (name
);
9132 for (i
= 0; i
< 3; i
++)
9134 Lisp_Object this_spec
, this_name
, this_aliases
, this_eol_type
;
9136 this_name
= AREF (eol_type
, i
);
9137 this_aliases
= Fcons (this_name
, Qnil
);
9138 this_eol_type
= (i
== 0 ? Qunix
: i
== 1 ? Qdos
: Qmac
);
9139 this_spec
= Fmake_vector (make_number (3), attrs
);
9140 ASET (this_spec
, 1, this_aliases
);
9141 ASET (this_spec
, 2, this_eol_type
);
9142 Fputhash (this_name
, this_spec
, Vcoding_system_hash_table
);
9143 Vcoding_system_list
= Fcons (this_name
, Vcoding_system_list
);
9144 val
= Fassoc (Fsymbol_name (this_name
), Vcoding_system_alist
);
9146 Vcoding_system_alist
9147 = Fcons (Fcons (Fsymbol_name (this_name
), Qnil
),
9148 Vcoding_system_alist
);
9152 spec_vec
= Fmake_vector (make_number (3), attrs
);
9153 ASET (spec_vec
, 1, aliases
);
9154 ASET (spec_vec
, 2, eol_type
);
9156 Fputhash (name
, spec_vec
, Vcoding_system_hash_table
);
9157 Vcoding_system_list
= Fcons (name
, Vcoding_system_list
);
9158 val
= Fassoc (Fsymbol_name (name
), Vcoding_system_alist
);
9160 Vcoding_system_alist
= Fcons (Fcons (Fsymbol_name (name
), Qnil
),
9161 Vcoding_system_alist
);
9164 int id
= coding_categories
[category
].id
;
9166 if (id
< 0 || EQ (name
, CODING_ID_NAME (id
)))
9167 setup_coding_system (name
, &coding_categories
[category
]);
9173 return Fsignal (Qwrong_number_of_arguments
,
9174 Fcons (intern ("define-coding-system-internal"),
9175 make_number (nargs
)));
9179 DEFUN ("coding-system-put", Fcoding_system_put
, Scoding_system_put
,
9181 doc
: /* Change value in CODING-SYSTEM's property list PROP to VAL. */)
9182 (coding_system
, prop
, val
)
9183 Lisp_Object coding_system
, prop
, val
;
9185 Lisp_Object spec
, attrs
;
9187 CHECK_CODING_SYSTEM_GET_SPEC (coding_system
, spec
);
9188 attrs
= AREF (spec
, 0);
9189 if (EQ (prop
, QCmnemonic
))
9191 if (! STRINGP (val
))
9192 CHECK_CHARACTER (val
);
9193 CODING_ATTR_MNEMONIC (attrs
) = val
;
9195 else if (EQ (prop
, QCdefalut_char
))
9198 val
= make_number (' ');
9200 CHECK_CHARACTER (val
);
9201 CODING_ATTR_DEFAULT_CHAR (attrs
) = val
;
9203 else if (EQ (prop
, QCdecode_translation_table
))
9205 if (! CHAR_TABLE_P (val
) && ! CONSP (val
))
9207 CODING_ATTR_DECODE_TBL (attrs
) = val
;
9209 else if (EQ (prop
, QCencode_translation_table
))
9211 if (! CHAR_TABLE_P (val
) && ! CONSP (val
))
9213 CODING_ATTR_ENCODE_TBL (attrs
) = val
;
9215 else if (EQ (prop
, QCpost_read_conversion
))
9218 CODING_ATTR_POST_READ (attrs
) = val
;
9220 else if (EQ (prop
, QCpre_write_conversion
))
9223 CODING_ATTR_PRE_WRITE (attrs
) = val
;
9225 else if (EQ (prop
, QCascii_compatible_p
))
9227 CODING_ATTR_ASCII_COMPAT (attrs
) = val
;
9230 CODING_ATTR_PLIST (attrs
)
9231 = Fplist_put (CODING_ATTR_PLIST (attrs
), prop
, val
);
9236 DEFUN ("define-coding-system-alias", Fdefine_coding_system_alias
,
9237 Sdefine_coding_system_alias
, 2, 2, 0,
9238 doc
: /* Define ALIAS as an alias for CODING-SYSTEM. */)
9239 (alias
, coding_system
)
9240 Lisp_Object alias
, coding_system
;
9242 Lisp_Object spec
, aliases
, eol_type
, val
;
9244 CHECK_SYMBOL (alias
);
9245 CHECK_CODING_SYSTEM_GET_SPEC (coding_system
, spec
);
9246 aliases
= AREF (spec
, 1);
9247 /* ALISES should be a list of length more than zero, and the first
9248 element is a base coding system. Append ALIAS at the tail of the
9250 while (!NILP (XCDR (aliases
)))
9251 aliases
= XCDR (aliases
);
9252 XSETCDR (aliases
, Fcons (alias
, Qnil
));
9254 eol_type
= AREF (spec
, 2);
9255 if (VECTORP (eol_type
))
9257 Lisp_Object subsidiaries
;
9260 subsidiaries
= make_subsidiaries (alias
);
9261 for (i
= 0; i
< 3; i
++)
9262 Fdefine_coding_system_alias (AREF (subsidiaries
, i
),
9263 AREF (eol_type
, i
));
9266 Fputhash (alias
, spec
, Vcoding_system_hash_table
);
9267 Vcoding_system_list
= Fcons (alias
, Vcoding_system_list
);
9268 val
= Fassoc (Fsymbol_name (alias
), Vcoding_system_alist
);
9270 Vcoding_system_alist
= Fcons (Fcons (Fsymbol_name (alias
), Qnil
),
9271 Vcoding_system_alist
);
9276 DEFUN ("coding-system-base", Fcoding_system_base
, Scoding_system_base
,
9278 doc
: /* Return the base of CODING-SYSTEM.
9279 Any alias or subsidiary coding system is not a base coding system. */)
9281 Lisp_Object coding_system
;
9283 Lisp_Object spec
, attrs
;
9285 if (NILP (coding_system
))
9286 return (Qno_conversion
);
9287 CHECK_CODING_SYSTEM_GET_SPEC (coding_system
, spec
);
9288 attrs
= AREF (spec
, 0);
9289 return CODING_ATTR_BASE_NAME (attrs
);
9292 DEFUN ("coding-system-plist", Fcoding_system_plist
, Scoding_system_plist
,
9294 doc
: "Return the property list of CODING-SYSTEM.")
9296 Lisp_Object coding_system
;
9298 Lisp_Object spec
, attrs
;
9300 if (NILP (coding_system
))
9301 coding_system
= Qno_conversion
;
9302 CHECK_CODING_SYSTEM_GET_SPEC (coding_system
, spec
);
9303 attrs
= AREF (spec
, 0);
9304 return CODING_ATTR_PLIST (attrs
);
9308 DEFUN ("coding-system-aliases", Fcoding_system_aliases
, Scoding_system_aliases
,
9310 doc
: /* Return the list of aliases of CODING-SYSTEM. */)
9312 Lisp_Object coding_system
;
9316 if (NILP (coding_system
))
9317 coding_system
= Qno_conversion
;
9318 CHECK_CODING_SYSTEM_GET_SPEC (coding_system
, spec
);
9319 return AREF (spec
, 1);
9322 DEFUN ("coding-system-eol-type", Fcoding_system_eol_type
,
9323 Scoding_system_eol_type
, 1, 1, 0,
9324 doc
: /* Return eol-type of CODING-SYSTEM.
9325 An eol-type is integer 0, 1, 2, or a vector of coding systems.
9327 Integer values 0, 1, and 2 indicate a format of end-of-line; LF, CRLF,
9328 and CR respectively.
9330 A vector value indicates that a format of end-of-line should be
9331 detected automatically. Nth element of the vector is the subsidiary
9332 coding system whose eol-type is N. */)
9334 Lisp_Object coding_system
;
9336 Lisp_Object spec
, eol_type
;
9339 if (NILP (coding_system
))
9340 coding_system
= Qno_conversion
;
9341 if (! CODING_SYSTEM_P (coding_system
))
9343 spec
= CODING_SYSTEM_SPEC (coding_system
);
9344 eol_type
= AREF (spec
, 2);
9345 if (VECTORP (eol_type
))
9346 return Fcopy_sequence (eol_type
);
9347 n
= EQ (eol_type
, Qunix
) ? 0 : EQ (eol_type
, Qdos
) ? 1 : 2;
9348 return make_number (n
);
9354 /*** 9. Post-amble ***/
9361 for (i
= 0; i
< coding_category_max
; i
++)
9363 coding_categories
[i
].id
= -1;
9364 coding_priorities
[i
] = i
;
9367 /* ISO2022 specific initialize routine. */
9368 for (i
= 0; i
< 0x20; i
++)
9369 iso_code_class
[i
] = ISO_control_0
;
9370 for (i
= 0x21; i
< 0x7F; i
++)
9371 iso_code_class
[i
] = ISO_graphic_plane_0
;
9372 for (i
= 0x80; i
< 0xA0; i
++)
9373 iso_code_class
[i
] = ISO_control_1
;
9374 for (i
= 0xA1; i
< 0xFF; i
++)
9375 iso_code_class
[i
] = ISO_graphic_plane_1
;
9376 iso_code_class
[0x20] = iso_code_class
[0x7F] = ISO_0x20_or_0x7F
;
9377 iso_code_class
[0xA0] = iso_code_class
[0xFF] = ISO_0xA0_or_0xFF
;
9378 iso_code_class
[ISO_CODE_SO
] = ISO_shift_out
;
9379 iso_code_class
[ISO_CODE_SI
] = ISO_shift_in
;
9380 iso_code_class
[ISO_CODE_SS2_7
] = ISO_single_shift_2_7
;
9381 iso_code_class
[ISO_CODE_ESC
] = ISO_escape
;
9382 iso_code_class
[ISO_CODE_SS2
] = ISO_single_shift_2
;
9383 iso_code_class
[ISO_CODE_SS3
] = ISO_single_shift_3
;
9384 iso_code_class
[ISO_CODE_CSI
] = ISO_control_sequence_introducer
;
9386 for (i
= 0; i
< 256; i
++)
9388 emacs_mule_bytes
[i
] = 1;
9390 emacs_mule_bytes
[EMACS_MULE_LEADING_CODE_PRIVATE_11
] = 3;
9391 emacs_mule_bytes
[EMACS_MULE_LEADING_CODE_PRIVATE_12
] = 3;
9392 emacs_mule_bytes
[EMACS_MULE_LEADING_CODE_PRIVATE_21
] = 4;
9393 emacs_mule_bytes
[EMACS_MULE_LEADING_CODE_PRIVATE_22
] = 4;
9401 staticpro (&Vcoding_system_hash_table
);
9403 Lisp_Object args
[2];
9406 Vcoding_system_hash_table
= Fmake_hash_table (2, args
);
9409 staticpro (&Vsjis_coding_system
);
9410 Vsjis_coding_system
= Qnil
;
9412 staticpro (&Vbig5_coding_system
);
9413 Vbig5_coding_system
= Qnil
;
9415 staticpro (&Vcode_conversion_reused_workbuf
);
9416 Vcode_conversion_reused_workbuf
= Qnil
;
9418 staticpro (&Vcode_conversion_workbuf_name
);
9419 Vcode_conversion_workbuf_name
= build_string (" *code-conversion-work*");
9421 reused_workbuf_in_use
= 0;
9423 DEFSYM (Qcharset
, "charset");
9424 DEFSYM (Qtarget_idx
, "target-idx");
9425 DEFSYM (Qcoding_system_history
, "coding-system-history");
9426 Fset (Qcoding_system_history
, Qnil
);
9428 /* Target FILENAME is the first argument. */
9429 Fput (Qinsert_file_contents
, Qtarget_idx
, make_number (0));
9430 /* Target FILENAME is the third argument. */
9431 Fput (Qwrite_region
, Qtarget_idx
, make_number (2));
9433 DEFSYM (Qcall_process
, "call-process");
9434 /* Target PROGRAM is the first argument. */
9435 Fput (Qcall_process
, Qtarget_idx
, make_number (0));
9437 DEFSYM (Qcall_process_region
, "call-process-region");
9438 /* Target PROGRAM is the third argument. */
9439 Fput (Qcall_process_region
, Qtarget_idx
, make_number (2));
9441 DEFSYM (Qstart_process
, "start-process");
9442 /* Target PROGRAM is the third argument. */
9443 Fput (Qstart_process
, Qtarget_idx
, make_number (2));
9445 DEFSYM (Qopen_network_stream
, "open-network-stream");
9446 /* Target SERVICE is the fourth argument. */
9447 Fput (Qopen_network_stream
, Qtarget_idx
, make_number (3));
9449 DEFSYM (Qcoding_system
, "coding-system");
9450 DEFSYM (Qcoding_aliases
, "coding-aliases");
9452 DEFSYM (Qeol_type
, "eol-type");
9453 DEFSYM (Qunix
, "unix");
9454 DEFSYM (Qdos
, "dos");
9456 DEFSYM (Qbuffer_file_coding_system
, "buffer-file-coding-system");
9457 DEFSYM (Qpost_read_conversion
, "post-read-conversion");
9458 DEFSYM (Qpre_write_conversion
, "pre-write-conversion");
9459 DEFSYM (Qdefault_char
, "default-char");
9460 DEFSYM (Qundecided
, "undecided");
9461 DEFSYM (Qno_conversion
, "no-conversion");
9462 DEFSYM (Qraw_text
, "raw-text");
9464 DEFSYM (Qiso_2022
, "iso-2022");
9466 DEFSYM (Qutf_8
, "utf-8");
9467 DEFSYM (Qutf_8_emacs
, "utf-8-emacs");
9469 DEFSYM (Qutf_16
, "utf-16");
9470 DEFSYM (Qbig
, "big");
9471 DEFSYM (Qlittle
, "little");
9473 DEFSYM (Qshift_jis
, "shift-jis");
9474 DEFSYM (Qbig5
, "big5");
9476 DEFSYM (Qcoding_system_p
, "coding-system-p");
9478 DEFSYM (Qcoding_system_error
, "coding-system-error");
9479 Fput (Qcoding_system_error
, Qerror_conditions
,
9480 Fcons (Qcoding_system_error
, Fcons (Qerror
, Qnil
)));
9481 Fput (Qcoding_system_error
, Qerror_message
,
9482 build_string ("Invalid coding system"));
9484 /* Intern this now in case it isn't already done.
9485 Setting this variable twice is harmless.
9486 But don't staticpro it here--that is done in alloc.c. */
9487 Qchar_table_extra_slots
= intern ("char-table-extra-slots");
9489 DEFSYM (Qtranslation_table
, "translation-table");
9490 Fput (Qtranslation_table
, Qchar_table_extra_slots
, make_number (2));
9491 DEFSYM (Qtranslation_table_id
, "translation-table-id");
9492 DEFSYM (Qtranslation_table_for_decode
, "translation-table-for-decode");
9493 DEFSYM (Qtranslation_table_for_encode
, "translation-table-for-encode");
9495 DEFSYM (Qvalid_codes
, "valid-codes");
9497 DEFSYM (Qemacs_mule
, "emacs-mule");
9499 DEFSYM (QCcategory
, ":category");
9500 DEFSYM (QCmnemonic
, ":mnemonic");
9501 DEFSYM (QCdefalut_char
, ":default-char");
9502 DEFSYM (QCdecode_translation_table
, ":decode-translation-table");
9503 DEFSYM (QCencode_translation_table
, ":encode-translation-table");
9504 DEFSYM (QCpost_read_conversion
, ":post-read-conversion");
9505 DEFSYM (QCpre_write_conversion
, ":pre-write-conversion");
9506 DEFSYM (QCascii_compatible_p
, ":ascii-compatible-p");
9508 Vcoding_category_table
9509 = Fmake_vector (make_number (coding_category_max
), Qnil
);
9510 staticpro (&Vcoding_category_table
);
9511 /* Followings are target of code detection. */
9512 ASET (Vcoding_category_table
, coding_category_iso_7
,
9513 intern ("coding-category-iso-7"));
9514 ASET (Vcoding_category_table
, coding_category_iso_7_tight
,
9515 intern ("coding-category-iso-7-tight"));
9516 ASET (Vcoding_category_table
, coding_category_iso_8_1
,
9517 intern ("coding-category-iso-8-1"));
9518 ASET (Vcoding_category_table
, coding_category_iso_8_2
,
9519 intern ("coding-category-iso-8-2"));
9520 ASET (Vcoding_category_table
, coding_category_iso_7_else
,
9521 intern ("coding-category-iso-7-else"));
9522 ASET (Vcoding_category_table
, coding_category_iso_8_else
,
9523 intern ("coding-category-iso-8-else"));
9524 ASET (Vcoding_category_table
, coding_category_utf_8
,
9525 intern ("coding-category-utf-8"));
9526 ASET (Vcoding_category_table
, coding_category_utf_16_be
,
9527 intern ("coding-category-utf-16-be"));
9528 ASET (Vcoding_category_table
, coding_category_utf_16_auto
,
9529 intern ("coding-category-utf-16-auto"));
9530 ASET (Vcoding_category_table
, coding_category_utf_16_le
,
9531 intern ("coding-category-utf-16-le"));
9532 ASET (Vcoding_category_table
, coding_category_utf_16_be_nosig
,
9533 intern ("coding-category-utf-16-be-nosig"));
9534 ASET (Vcoding_category_table
, coding_category_utf_16_le_nosig
,
9535 intern ("coding-category-utf-16-le-nosig"));
9536 ASET (Vcoding_category_table
, coding_category_charset
,
9537 intern ("coding-category-charset"));
9538 ASET (Vcoding_category_table
, coding_category_sjis
,
9539 intern ("coding-category-sjis"));
9540 ASET (Vcoding_category_table
, coding_category_big5
,
9541 intern ("coding-category-big5"));
9542 ASET (Vcoding_category_table
, coding_category_ccl
,
9543 intern ("coding-category-ccl"));
9544 ASET (Vcoding_category_table
, coding_category_emacs_mule
,
9545 intern ("coding-category-emacs-mule"));
9546 /* Followings are NOT target of code detection. */
9547 ASET (Vcoding_category_table
, coding_category_raw_text
,
9548 intern ("coding-category-raw-text"));
9549 ASET (Vcoding_category_table
, coding_category_undecided
,
9550 intern ("coding-category-undecided"));
9552 DEFSYM (Qinsufficient_source
, "insufficient-source");
9553 DEFSYM (Qinconsistent_eol
, "inconsistent-eol");
9554 DEFSYM (Qinvalid_source
, "invalid-source");
9555 DEFSYM (Qinterrupted
, "interrupted");
9556 DEFSYM (Qinsufficient_memory
, "insufficient-memory");
9557 DEFSYM (Qcoding_system_define_form
, "coding-system-define-form");
9559 defsubr (&Scoding_system_p
);
9560 defsubr (&Sread_coding_system
);
9561 defsubr (&Sread_non_nil_coding_system
);
9562 defsubr (&Scheck_coding_system
);
9563 defsubr (&Sdetect_coding_region
);
9564 defsubr (&Sdetect_coding_string
);
9565 defsubr (&Sfind_coding_systems_region_internal
);
9566 defsubr (&Sunencodable_char_position
);
9567 defsubr (&Scheck_coding_systems_region
);
9568 defsubr (&Sdecode_coding_region
);
9569 defsubr (&Sencode_coding_region
);
9570 defsubr (&Sdecode_coding_string
);
9571 defsubr (&Sencode_coding_string
);
9572 defsubr (&Sdecode_sjis_char
);
9573 defsubr (&Sencode_sjis_char
);
9574 defsubr (&Sdecode_big5_char
);
9575 defsubr (&Sencode_big5_char
);
9576 defsubr (&Sset_terminal_coding_system_internal
);
9577 defsubr (&Sset_safe_terminal_coding_system_internal
);
9578 defsubr (&Sterminal_coding_system
);
9579 defsubr (&Sset_keyboard_coding_system_internal
);
9580 defsubr (&Skeyboard_coding_system
);
9581 defsubr (&Sfind_operation_coding_system
);
9582 defsubr (&Sset_coding_system_priority
);
9583 defsubr (&Sdefine_coding_system_internal
);
9584 defsubr (&Sdefine_coding_system_alias
);
9585 defsubr (&Scoding_system_put
);
9586 defsubr (&Scoding_system_base
);
9587 defsubr (&Scoding_system_plist
);
9588 defsubr (&Scoding_system_aliases
);
9589 defsubr (&Scoding_system_eol_type
);
9590 defsubr (&Scoding_system_priority_list
);
9592 DEFVAR_LISP ("coding-system-list", &Vcoding_system_list
,
9593 doc
: /* List of coding systems.
9595 Do not alter the value of this variable manually. This variable should be
9596 updated by the functions `define-coding-system' and
9597 `define-coding-system-alias'. */);
9598 Vcoding_system_list
= Qnil
;
9600 DEFVAR_LISP ("coding-system-alist", &Vcoding_system_alist
,
9601 doc
: /* Alist of coding system names.
9602 Each element is one element list of coding system name.
9603 This variable is given to `completing-read' as TABLE argument.
9605 Do not alter the value of this variable manually. This variable should be
9606 updated by the functions `make-coding-system' and
9607 `define-coding-system-alias'. */);
9608 Vcoding_system_alist
= Qnil
;
9610 DEFVAR_LISP ("coding-category-list", &Vcoding_category_list
,
9611 doc
: /* List of coding-categories (symbols) ordered by priority.
9613 On detecting a coding system, Emacs tries code detection algorithms
9614 associated with each coding-category one by one in this order. When
9615 one algorithm agrees with a byte sequence of source text, the coding
9616 system bound to the corresponding coding-category is selected.
9618 Don't modify this variable directly, but use `set-coding-priority'. */);
9622 Vcoding_category_list
= Qnil
;
9623 for (i
= coding_category_max
- 1; i
>= 0; i
--)
9624 Vcoding_category_list
9625 = Fcons (XVECTOR (Vcoding_category_table
)->contents
[i
],
9626 Vcoding_category_list
);
9629 DEFVAR_LISP ("coding-system-for-read", &Vcoding_system_for_read
,
9630 doc
: /* Specify the coding system for read operations.
9631 It is useful to bind this variable with `let', but do not set it globally.
9632 If the value is a coding system, it is used for decoding on read operation.
9633 If not, an appropriate element is used from one of the coding system alists:
9634 There are three such tables, `file-coding-system-alist',
9635 `process-coding-system-alist', and `network-coding-system-alist'. */);
9636 Vcoding_system_for_read
= Qnil
;
9638 DEFVAR_LISP ("coding-system-for-write", &Vcoding_system_for_write
,
9639 doc
: /* Specify the coding system for write operations.
9640 Programs bind this variable with `let', but you should not set it globally.
9641 If the value is a coding system, it is used for encoding of output,
9642 when writing it to a file and when sending it to a file or subprocess.
9644 If this does not specify a coding system, an appropriate element
9645 is used from one of the coding system alists:
9646 There are three such tables, `file-coding-system-alist',
9647 `process-coding-system-alist', and `network-coding-system-alist'.
9648 For output to files, if the above procedure does not specify a coding system,
9649 the value of `buffer-file-coding-system' is used. */);
9650 Vcoding_system_for_write
= Qnil
;
9652 DEFVAR_LISP ("last-coding-system-used", &Vlast_coding_system_used
,
9654 Coding system used in the latest file or process I/O. */);
9655 Vlast_coding_system_used
= Qnil
;
9657 DEFVAR_LISP ("last-code-conversion-error", &Vlast_code_conversion_error
,
9659 Error status of the last code conversion.
9661 When an error was detected in the last code conversion, this variable
9662 is set to one of the following symbols.
9663 `insufficient-source'
9667 `insufficient-memory'
9668 When no error was detected, the value doesn't change. So, to check
9669 the error status of a code conversion by this variable, you must
9670 explicitly set this variable to nil before performing code
9672 Vlast_code_conversion_error
= Qnil
;
9674 DEFVAR_BOOL ("inhibit-eol-conversion", &inhibit_eol_conversion
,
9676 *Non-nil means always inhibit code conversion of end-of-line format.
9677 See info node `Coding Systems' and info node `Text and Binary' concerning
9678 such conversion. */);
9679 inhibit_eol_conversion
= 0;
9681 DEFVAR_BOOL ("inherit-process-coding-system", &inherit_process_coding_system
,
9683 Non-nil means process buffer inherits coding system of process output.
9684 Bind it to t if the process output is to be treated as if it were a file
9685 read from some filesystem. */);
9686 inherit_process_coding_system
= 0;
9688 DEFVAR_LISP ("file-coding-system-alist", &Vfile_coding_system_alist
,
9690 Alist to decide a coding system to use for a file I/O operation.
9691 The format is ((PATTERN . VAL) ...),
9692 where PATTERN is a regular expression matching a file name,
9693 VAL is a coding system, a cons of coding systems, or a function symbol.
9694 If VAL is a coding system, it is used for both decoding and encoding
9696 If VAL is a cons of coding systems, the car part is used for decoding,
9697 and the cdr part is used for encoding.
9698 If VAL is a function symbol, the function must return a coding system
9699 or a cons of coding systems which are used as above. The function is
9700 called with an argument that is a list of the arguments with which
9701 `find-operation-coding-system' was called. If the function can't decide
9702 a coding system, it can return `undecided' so that the normal
9703 code-detection is performed.
9705 See also the function `find-operation-coding-system'
9706 and the variable `auto-coding-alist'. */);
9707 Vfile_coding_system_alist
= Qnil
;
9709 DEFVAR_LISP ("process-coding-system-alist", &Vprocess_coding_system_alist
,
9711 Alist to decide a coding system to use for a process I/O operation.
9712 The format is ((PATTERN . VAL) ...),
9713 where PATTERN is a regular expression matching a program name,
9714 VAL is a coding system, a cons of coding systems, or a function symbol.
9715 If VAL is a coding system, it is used for both decoding what received
9716 from the program and encoding what sent to the program.
9717 If VAL is a cons of coding systems, the car part is used for decoding,
9718 and the cdr part is used for encoding.
9719 If VAL is a function symbol, the function must return a coding system
9720 or a cons of coding systems which are used as above.
9722 See also the function `find-operation-coding-system'. */);
9723 Vprocess_coding_system_alist
= Qnil
;
9725 DEFVAR_LISP ("network-coding-system-alist", &Vnetwork_coding_system_alist
,
9727 Alist to decide a coding system to use for a network I/O operation.
9728 The format is ((PATTERN . VAL) ...),
9729 where PATTERN is a regular expression matching a network service name
9730 or is a port number to connect to,
9731 VAL is a coding system, a cons of coding systems, or a function symbol.
9732 If VAL is a coding system, it is used for both decoding what received
9733 from the network stream and encoding what sent to the network stream.
9734 If VAL is a cons of coding systems, the car part is used for decoding,
9735 and the cdr part is used for encoding.
9736 If VAL is a function symbol, the function must return a coding system
9737 or a cons of coding systems which are used as above.
9739 See also the function `find-operation-coding-system'. */);
9740 Vnetwork_coding_system_alist
= Qnil
;
9742 DEFVAR_LISP ("locale-coding-system", &Vlocale_coding_system
,
9743 doc
: /* Coding system to use with system messages.
9744 Also used for decoding keyboard input on X Window system. */);
9745 Vlocale_coding_system
= Qnil
;
9747 /* The eol mnemonics are reset in startup.el system-dependently. */
9748 DEFVAR_LISP ("eol-mnemonic-unix", &eol_mnemonic_unix
,
9750 *String displayed in mode line for UNIX-like (LF) end-of-line format. */);
9751 eol_mnemonic_unix
= build_string (":");
9753 DEFVAR_LISP ("eol-mnemonic-dos", &eol_mnemonic_dos
,
9755 *String displayed in mode line for DOS-like (CRLF) end-of-line format. */);
9756 eol_mnemonic_dos
= build_string ("\\");
9758 DEFVAR_LISP ("eol-mnemonic-mac", &eol_mnemonic_mac
,
9760 *String displayed in mode line for MAC-like (CR) end-of-line format. */);
9761 eol_mnemonic_mac
= build_string ("/");
9763 DEFVAR_LISP ("eol-mnemonic-undecided", &eol_mnemonic_undecided
,
9765 *String displayed in mode line when end-of-line format is not yet determined. */);
9766 eol_mnemonic_undecided
= build_string (":");
9768 DEFVAR_LISP ("enable-character-translation", &Venable_character_translation
,
9770 *Non-nil enables character translation while encoding and decoding. */);
9771 Venable_character_translation
= Qt
;
9773 DEFVAR_LISP ("standard-translation-table-for-decode",
9774 &Vstandard_translation_table_for_decode
,
9775 doc
: /* Table for translating characters while decoding. */);
9776 Vstandard_translation_table_for_decode
= Qnil
;
9778 DEFVAR_LISP ("standard-translation-table-for-encode",
9779 &Vstandard_translation_table_for_encode
,
9780 doc
: /* Table for translating characters while encoding. */);
9781 Vstandard_translation_table_for_encode
= Qnil
;
9783 DEFVAR_LISP ("charset-revision-table", &Vcharset_revision_table
,
9784 doc
: /* Alist of charsets vs revision numbers.
9785 While encoding, if a charset (car part of an element) is found,
9786 designate it with the escape sequence identifying revision (cdr part
9787 of the element). */);
9788 Vcharset_revision_table
= Qnil
;
9790 DEFVAR_LISP ("default-process-coding-system",
9791 &Vdefault_process_coding_system
,
9792 doc
: /* Cons of coding systems used for process I/O by default.
9793 The car part is used for decoding a process output,
9794 the cdr part is used for encoding a text to be sent to a process. */);
9795 Vdefault_process_coding_system
= Qnil
;
9797 DEFVAR_LISP ("latin-extra-code-table", &Vlatin_extra_code_table
,
9799 Table of extra Latin codes in the range 128..159 (inclusive).
9800 This is a vector of length 256.
9801 If Nth element is non-nil, the existence of code N in a file
9802 \(or output of subprocess) doesn't prevent it to be detected as
9803 a coding system of ISO 2022 variant which has a flag
9804 `accept-latin-extra-code' t (e.g. iso-latin-1) on reading a file
9805 or reading output of a subprocess.
9806 Only 128th through 159th elements has a meaning. */);
9807 Vlatin_extra_code_table
= Fmake_vector (make_number (256), Qnil
);
9809 DEFVAR_LISP ("select-safe-coding-system-function",
9810 &Vselect_safe_coding_system_function
,
9812 Function to call to select safe coding system for encoding a text.
9814 If set, this function is called to force a user to select a proper
9815 coding system which can encode the text in the case that a default
9816 coding system used in each operation can't encode the text. The
9817 function should take care that the buffer is not modified while
9818 the coding system is being selected.
9820 The default value is `select-safe-coding-system' (which see). */);
9821 Vselect_safe_coding_system_function
= Qnil
;
9823 DEFVAR_BOOL ("coding-system-require-warning",
9824 &coding_system_require_warning
,
9825 doc
: /* Internal use only.
9826 If non-nil, on writing a file, `select-safe-coding-system-function' is
9827 called even if `coding-system-for-write' is non-nil. The command
9828 `universal-coding-system-argument' binds this variable to t temporarily. */);
9829 coding_system_require_warning
= 0;
9832 DEFVAR_BOOL ("inhibit-iso-escape-detection",
9833 &inhibit_iso_escape_detection
,
9835 If non-nil, Emacs ignores ISO2022's escape sequence on code detection.
9837 By default, on reading a file, Emacs tries to detect how the text is
9838 encoded. This code detection is sensitive to escape sequences. If
9839 the sequence is valid as ISO2022, the code is determined as one of
9840 the ISO2022 encodings, and the file is decoded by the corresponding
9841 coding system (e.g. `iso-2022-7bit').
9843 However, there may be a case that you want to read escape sequences in
9844 a file as is. In such a case, you can set this variable to non-nil.
9845 Then, as the code detection ignores any escape sequences, no file is
9846 detected as encoded in some ISO2022 encoding. The result is that all
9847 escape sequences become visible in a buffer.
9849 The default value is nil, and it is strongly recommended not to change
9850 it. That is because many Emacs Lisp source files that contain
9851 non-ASCII characters are encoded by the coding system `iso-2022-7bit'
9852 in Emacs's distribution, and they won't be decoded correctly on
9853 reading if you suppress escape sequence detection.
9855 The other way to read escape sequences in a file without decoding is
9856 to explicitly specify some coding system that doesn't use ISO2022's
9857 escape sequence (e.g `latin-1') on reading by \\[universal-coding-system-argument]. */);
9858 inhibit_iso_escape_detection
= 0;
9860 DEFVAR_LISP ("translation-table-for-input", &Vtranslation_table_for_input
,
9861 doc
: /* Char table for translating self-inserting characters.
9862 This is applied to the result of input methods, not their input. See also
9863 `keyboard-translate-table'. */);
9864 Vtranslation_table_for_input
= Qnil
;
9867 Lisp_Object args
[coding_arg_max
];
9868 Lisp_Object plist
[16];
9871 for (i
= 0; i
< coding_arg_max
; i
++)
9874 plist
[0] = intern (":name");
9875 plist
[1] = args
[coding_arg_name
] = Qno_conversion
;
9876 plist
[2] = intern (":mnemonic");
9877 plist
[3] = args
[coding_arg_mnemonic
] = make_number ('=');
9878 plist
[4] = intern (":coding-type");
9879 plist
[5] = args
[coding_arg_coding_type
] = Qraw_text
;
9880 plist
[6] = intern (":ascii-compatible-p");
9881 plist
[7] = args
[coding_arg_ascii_compatible_p
] = Qt
;
9882 plist
[8] = intern (":default-char");
9883 plist
[9] = args
[coding_arg_default_char
] = make_number (0);
9884 plist
[10] = intern (":for-unibyte");
9885 plist
[11] = args
[coding_arg_for_unibyte
] = Qt
;
9886 plist
[12] = intern (":docstring");
9887 plist
[13] = build_string ("Do no conversion.\n\
9889 When you visit a file with this coding, the file is read into a\n\
9890 unibyte buffer as is, thus each byte of a file is treated as a\n\
9892 plist
[14] = intern (":eol-type");
9893 plist
[15] = args
[coding_arg_eol_type
] = Qunix
;
9894 args
[coding_arg_plist
] = Flist (16, plist
);
9895 Fdefine_coding_system_internal (coding_arg_max
, args
);
9897 plist
[1] = args
[coding_arg_name
] = Qundecided
;
9898 plist
[3] = args
[coding_arg_mnemonic
] = make_number ('-');
9899 plist
[5] = args
[coding_arg_coding_type
] = Qundecided
;
9900 /* This is already set.
9901 plist[7] = args[coding_arg_ascii_compatible_p] = Qt; */
9902 plist
[8] = intern (":charset-list");
9903 plist
[9] = args
[coding_arg_charset_list
] = Fcons (Qascii
, Qnil
);
9904 plist
[11] = args
[coding_arg_for_unibyte
] = Qnil
;
9905 plist
[13] = build_string ("No conversion on encoding, automatic conversion on decoding.");
9906 plist
[15] = args
[coding_arg_eol_type
] = Qnil
;
9907 args
[coding_arg_plist
] = Flist (16, plist
);
9908 Fdefine_coding_system_internal (coding_arg_max
, args
);
9911 setup_coding_system (Qno_conversion
, &safe_terminal_coding
);
9916 for (i
= 0; i
< coding_category_max
; i
++)
9917 Fset (AREF (Vcoding_category_table
, i
), Qno_conversion
);
9919 #if defined (MSDOS) || defined (WINDOWSNT)
9920 system_eol_type
= Qdos
;
9922 system_eol_type
= Qunix
;
9924 staticpro (&system_eol_type
);
9928 emacs_strerror (error_number
)
9933 synchronize_system_messages_locale ();
9934 str
= strerror (error_number
);
9936 if (! NILP (Vlocale_coding_system
))
9938 Lisp_Object dec
= code_convert_string_norecord (build_string (str
),
9939 Vlocale_coding_system
,
9941 str
= (char *) SDATA (dec
);
9949 /* arch-tag: 3a3a2b01-5ff6-4071-9afe-f5b808d9229d
9950 (do not change this comment) */