2. Emacs' internal format (emacs-mule) handlers
3. ISO2022 handlers
4. Shift-JIS and BIG5 handlers
- 5. End-of-line handlers
- 6. C library functions
- 7. Emacs Lisp library functions
- 8. Post-amble
+ 5. CCL handlers
+ 6. End-of-line handlers
+ 7. C library functions
+ 8. Emacs Lisp library functions
+ 9. Post-amble
*/
/* Decode one ASCII character C. */
-#define DECODE_CHARACTER_ASCII(c) \
- do { \
- if (COMPOSING_P (coding->composing)) \
- *dst++ = 0xA0, *dst++ = (c) | 0x80; \
- else \
- { \
- *dst++ = (c); \
- coding->produced_char++; \
- } \
+#define DECODE_CHARACTER_ASCII(c) \
+ do { \
+ if (COMPOSING_P (coding->composing)) \
+ { \
+ *dst++ = 0xA0, *dst++ = (c) | 0x80; \
+ coding->composed_chars++; \
+ if (((c) | 0x80) < 0xA0) \
+ coding->fake_multibyte = 1; \
+ } \
+ else \
+ { \
+ *dst++ = (c); \
+ coding->produced_char++; \
+ if ((c) >= 0x80) \
+ coding->fake_multibyte = 1; \
+ } \
} while (0)
/* Decode one DIMENSION1 character whose charset is CHARSET and whose
do { \
unsigned char leading_code = CHARSET_LEADING_CODE_BASE (charset); \
if (COMPOSING_P (coding->composing)) \
- *dst++ = leading_code + 0x20; \
+ { \
+ *dst++ = leading_code + 0x20; \
+ coding->composed_chars++; \
+ } \
else \
{ \
*dst++ = leading_code; \
if (leading_code = CHARSET_LEADING_CODE_EXT (charset)) \
*dst++ = leading_code; \
*dst++ = (c) | 0x80; \
+ if (((c) | 0x80) < 0xA0) \
+ coding->fake_multibyte = 1; \
} while (0)
/* Decode one DIMENSION2 character whose charset is CHARSET and whose
do { \
DECODE_CHARACTER_DIMENSION1 (charset, c1); \
*dst++ = (c2) | 0x80; \
+ if (((c2) | 0x80) < 0xA0) \
+ coding->fake_multibyte = 1; \
} while (0)
\f
Lisp_Object Qno_conversion, Qundecided;
Lisp_Object Qcoding_system_history;
Lisp_Object Qsafe_charsets;
+Lisp_Object Qvalid_codes;
extern Lisp_Object Qinsert_file_contents, Qwrite_region;
Lisp_Object Qcall_process, Qcall_process_region, Qprocess_argument;
Lisp_Object Vselect_safe_coding_system_function;
-/* Mnemonic character of each format of end-of-line. */
-int eol_mnemonic_unix, eol_mnemonic_dos, eol_mnemonic_mac;
-/* Mnemonic character to indicate format of end-of-line is not yet
+/* Mnemonic string for each format of end-of-line. */
+Lisp_Object eol_mnemonic_unix, eol_mnemonic_dos, eol_mnemonic_mac;
+/* Mnemonic string to indicate format of end-of-line is not yet
decided. */
-int eol_mnemonic_undecided;
+Lisp_Object eol_mnemonic_undecided;
/* Format of end-of-line decided by system. This is CODING_EOL_LF on
Unix, CODING_EOL_CRLF on DOS/Windows, and CODING_EOL_CR on Mac. */
Lisp_Object Vlast_coding_system_used;
/* A vector of length 256 which contains information about special
- Latin codes (espepcially for dealing with Microsoft code). */
+ Latin codes (especially for dealing with Microsoft codes). */
Lisp_Object Vlatin_extra_code_table;
/* Flag to inhibit code conversion of end-of-line format. */
int inhibit_eol_conversion;
+/* Flag to make buffer-file-coding-system inherit from process-coding. */
+int inherit_process_coding_system;
+
/* Coding system to be used to encode text for terminal display. */
struct coding_system terminal_coding;
/* Coding system of what is sent from terminal keyboard. */
struct coding_system keyboard_coding;
+/* Default coding system to be used to write a file. */
+struct coding_system default_buffer_file_coding;
+
Lisp_Object Vfile_coding_system_alist;
Lisp_Object Vprocess_coding_system_alist;
Lisp_Object Vnetwork_coding_system_alist;
"coding-category-iso-8-2",
"coding-category-iso-7-else",
"coding-category-iso-8-else",
+ "coding-category-ccl",
"coding-category-big5",
"coding-category-raw-text",
"coding-category-binary"
};
-/* Table pointers to coding systems corresponding to each coding
+/* Table of pointers to coding systems corresponding to each coding
categories. */
struct coding_system *coding_system_table[CODING_CATEGORY_IDX_MAX];
-/* Flag to tell if we look up unification table on character code
+/* Table of coding category masks. Nth element is a mask for a coding
+ cateogry of which priority is Nth. */
+static
+int coding_priorities[CODING_CATEGORY_IDX_MAX];
+
+/* Flag to tell if we look up translation table on character code
conversion. */
-Lisp_Object Venable_character_unification;
-/* Standard unification table to look up on decoding (reading). */
-Lisp_Object Vstandard_character_unification_table_for_decode;
-/* Standard unification table to look up on encoding (writing). */
-Lisp_Object Vstandard_character_unification_table_for_encode;
+Lisp_Object Venable_character_translation;
+/* Standard translation table to look up on decoding (reading). */
+Lisp_Object Vstandard_translation_table_for_decode;
+/* Standard translation table to look up on encoding (writing). */
+Lisp_Object Vstandard_translation_table_for_encode;
-Lisp_Object Qcharacter_unification_table;
-Lisp_Object Qcharacter_unification_table_for_decode;
-Lisp_Object Qcharacter_unification_table_for_encode;
+Lisp_Object Qtranslation_table;
+Lisp_Object Qtranslation_table_id;
+Lisp_Object Qtranslation_table_for_decode;
+Lisp_Object Qtranslation_table_for_encode;
/* Alist of charsets vs revision number. */
Lisp_Object Vcharset_revision_alist;
/*** 3. ISO2022 handlers ***/
/* The following note describes the coding system ISO2022 briefly.
- Since the intention of this note is to help in understanding of
- the programs in this file, some parts are NOT ACCURATE or OVERLY
- SIMPLIFIED. For the thorough understanding, please refer to the
+ Since the intention of this note is to help understand the
+ functions in this file, some parts are NOT ACCURATE or OVERLY
+ SIMPLIFIED. For thorough understanding, please refer to the
original document of ISO2022.
ISO2022 provides many mechanisms to encode several character sets
- in 7-bit and 8-bit environment. If one chooses 7-bite environment,
- all text is encoded by codes of less than 128. This may make the
- encoded text a little bit longer, but the text gets more stability
- to pass through several gateways (some of them strip off the MSB).
-
- There are two kinds of character set: control character set and
+ in 7-bit and 8-bit environments. For 7-bite environments, all text
+ is encoded using bytes less than 128. This may make the encoded
+ text a little bit longer, but the text passes more easily through
+ several gateways, some of which strip off MSB (Most Signigant Bit).
+
+ There are two kinds of character sets: control character set and
graphic character set. The former contains control characters such
as `newline' and `escape' to provide control functions (control
- functions are provided also by escape sequences). The latter
- contains graphic characters such as ' A' and '-'. Emacs recognizes
+ functions are also provided by escape sequences). The latter
+ contains graphic characters such as 'A' and '-'. Emacs recognizes
two control character sets and many graphic character sets.
Graphic character sets are classified into one of the following
- four classes, DIMENSION1_CHARS94, DIMENSION1_CHARS96,
- DIMENSION2_CHARS94, DIMENSION2_CHARS96 according to the number of
- bytes (DIMENSION) and the number of characters in one dimension
- (CHARS) of the set. In addition, each character set is assigned an
- identification tag (called "final character" and denoted as <F>
- here after) which is unique in each class. <F> of each character
- set is decided by ECMA(*) when it is registered in ISO. Code range
- of <F> is 0x30..0x7F (0x30..0x3F are for private use only).
+ four classes, according to the number of bytes (DIMENSION) and
+ number of characters in one dimension (CHARS) of the set:
+ - DIMENSION1_CHARS94
+ - DIMENSION1_CHARS96
+ - DIMENSION2_CHARS94
+ - DIMENSION2_CHARS96
+
+ In addition, each character set is assigned an identification tag,
+ unique for each set, called "final character" (denoted as <F>
+ hereafter). The <F> of each character set is decided by ECMA(*)
+ when it is registered in ISO. The code range of <F> is 0x30..0x7F
+ (0x30..0x3F are for private use only).
Note (*): ECMA = European Computer Manufacturers Association
o DIMENSION2_CHARS94 -- GB2312('A'), JISX0208('B'), ...
o DIMENSION2_CHARS96 -- none for the moment
- A code area (1byte=8bits) is divided into 4 areas, C0, GL, C1, and GR.
+ A code area (1 byte=8 bits) is divided into 4 areas, C0, GL, C1, and GR.
C0 [0x00..0x1F] -- control character plane 0
GL [0x20..0x7F] -- graphic character plane 0
C1 [0x80..0x9F] -- control character plane 1
GR [0xA0..0xFF] -- graphic character plane 1
A control character set is directly designated and invoked to C0 or
- C1 by an escape sequence. The most common case is that ISO646's
- control character set is designated/invoked to C0 and ISO6429's
- control character set is designated/invoked to C1, and usually
- these designations/invocations are omitted in a coded text. With
- 7-bit environment, only C0 can be used, and a control character for
- C1 is encoded by an appropriate escape sequence to fit in the
- environment. All control characters for C1 are defined the
- corresponding escape sequences.
+ C1 by an escape sequence. The most common case is that:
+ - ISO646's control character set is designated/invoked to C0, and
+ - ISO6429's control character set is designated/invoked to C1,
+ and usually these designations/invocations are omitted in encoded
+ text. In a 7-bit environment, only C0 can be used, and a control
+ character for C1 is encoded by an appropriate escape sequence to
+ fit into the environment. All control characters for C1 are
+ defined to have corresponding escape sequences.
A graphic character set is at first designated to one of four
graphic registers (G0 through G3), then these graphic registers are
invoked to GL or GR. These designations and invocations can be
done independently. The most common case is that G0 is invoked to
- GL, G1 is invoked to GR, and ASCII is designated to G0, and usually
- these invocations and designations are omitted in a coded text.
- With 7-bit environment, only GL can be used.
+ GL, G1 is invoked to GR, and ASCII is designated to G0. Usually
+ these invocations and designations are omitted in encoded text.
+ In a 7-bit environment, only GL can be used.
- When a graphic character set of CHARS94 is invoked to GL, code 0x20
- and 0x7F of GL area work as control characters SPACE and DEL
- respectively, and code 0xA0 and 0xFF of GR area should not be used.
+ When a graphic character set of CHARS94 is invoked to GL, codes
+ 0x20 and 0x7F of the GL area work as control characters SPACE and
+ DEL respectively, and codes 0xA0 and 0xFF of the GR area should not
+ be used.
There are two ways of invocation: locking-shift and single-shift.
With locking-shift, the invocation lasts until the next different
- invocation, whereas with single-shift, the invocation works only
- for the following character and doesn't affect locking-shift.
- Invocations are done by the following control characters or escape
- sequences.
+ invocation, whereas with single-shift, the invocation affects the
+ following character only and doesn't affect the locking-shift
+ state. Invocations are done by the following control characters or
+ escape sequences:
----------------------------------------------------------------------
- function control char escape sequence description
+ abbrev function cntrl escape seq description
----------------------------------------------------------------------
- SI (shift-in) 0x0F none invoke G0 to GL
- SO (shift-out) 0x0E none invoke G1 to GL
- LS2 (locking-shift-2) none ESC 'n' invoke G2 into GL
- LS3 (locking-shift-3) none ESC 'o' invoke G3 into GL
- SS2 (single-shift-2) 0x8E ESC 'N' invoke G2 into GL
- SS3 (single-shift-3) 0x8F ESC 'O' invoke G3 into GL
+ SI/LS0 (shift-in) 0x0F none invoke G0 into GL
+ SO/LS1 (shift-out) 0x0E none invoke G1 into GL
+ LS2 (locking-shift-2) none ESC 'n' invoke G2 into GL
+ LS3 (locking-shift-3) none ESC 'o' invoke G3 into GL
+ LS1R (locking-shift-1 right) none ESC '~' invoke G1 into GR (*)
+ LS2R (locking-shift-2 right) none ESC '}' invoke G2 into GR (*)
+ LS3R (locking-shift 3 right) none ESC '|' invoke G3 into GR (*)
+ SS2 (single-shift-2) 0x8E ESC 'N' invoke G2 for one char
+ SS3 (single-shift-3) 0x8F ESC 'O' invoke G3 for one char
----------------------------------------------------------------------
- The first four are for locking-shift. Control characters for these
- functions are defined by macros ISO_CODE_XXX in `coding.h'.
+ (*) These are not used by any known coding system.
+
+ Control characters for these functions are defined by macros
+ ISO_CODE_XXX in `coding.h'.
- Designations are done by the following escape sequences.
+ Designations are done by the following escape sequences:
----------------------------------------------------------------------
escape sequence description
----------------------------------------------------------------------
----------------------------------------------------------------------
In this list, "DIMENSION1_CHARS94<F>" means a graphic character set
- of dimension 1, chars 94, and final character <F>, and etc.
+ of dimension 1, chars 94, and final character <F>, etc...
Note (*): Although these designations are not allowed in ISO2022,
Emacs accepts them on decoding, and produces them on encoding
- CHARS96 character set in a coding system which is characterized as
+ CHARS96 character sets in a coding system which is characterized as
7-bit environment, non-locking-shift, and non-single-shift.
Note (**): If <F> is '@', 'A', or 'B', the intermediate character
- '(' can be omitted. We call this as "short-form" here after.
+ '(' can be omitted. We refer to this as "short-form" hereafter.
Now you may notice that there are a lot of ways for encoding the
- same multilingual text in ISO2022. Actually, there exists many
- coding systems such as Compound Text (used in X's inter client
- communication, ISO-2022-JP (used in Japanese Internet), ISO-2022-KR
- (used in Korean Internet), EUC (Extended UNIX Code, used in Asian
+ same multilingual text in ISO2022. Actually, there exist many
+ coding systems such as Compound Text (used in X11's inter client
+ communication, ISO-2022-JP (used in Japanese internet), ISO-2022-KR
+ (used in Korean internet), EUC (Extended UNIX Code, used in Asian
localized platforms), and all of these are variants of ISO2022.
In addition to the above, Emacs handles two more kinds of escape
sequences: ISO6429's direction specification and Emacs' private
sequence for specifying character composition.
- ISO6429's direction specification takes the following format:
+ ISO6429's direction specification takes the following form:
o CSI ']' -- end of the current direction
o CSI '0' ']' -- end of the current direction
o CSI '1' ']' -- start of left-to-right text
o CSI '2' ']' -- start of right-to-left text
The control character CSI (0x9B: control sequence introducer) is
- abbreviated to the escape sequence ESC '[' in 7-bit environment.
-
- Character composition specification takes the following format:
+ abbreviated to the escape sequence ESC '[' in a 7-bit environment.
+
+ Character composition specification takes the following form:
o ESC '0' -- start character composition
o ESC '1' -- end character composition
- Since these are not standard escape sequences of any ISO, the use
- of them for these meaning is restricted to Emacs only. */
+ Since these are not standard escape sequences of any ISO standard,
+ the use of them for these meaning is restricted to Emacs only. */
enum iso_code_class_type iso_code_class[256];
-#define CHARSET_OK(idx, charset) \
- (CODING_SPEC_ISO_REQUESTED_DESIGNATION \
- (coding_system_table[idx], charset) \
- != CODING_SPEC_ISO_NO_REQUESTED_DESIGNATION)
+#define CHARSET_OK(idx, charset) \
+ (coding_system_table[idx] \
+ && (coding_system_table[idx]->safe_charsets[charset] \
+ || (CODING_SPEC_ISO_REQUESTED_DESIGNATION \
+ (coding_system_table[idx], charset) \
+ != CODING_SPEC_ISO_NO_REQUESTED_DESIGNATION)))
#define SHIFT_OUT_OK(idx) \
(CODING_SPEC_ISO_INITIAL_DESIGNATION (coding_system_table[idx], 1) >= 0)
{
int mask = CODING_CATEGORY_MASK_ISO;
int mask_found = 0;
- int reg[4], shift_out = 0;
+ int reg[4], shift_out = 0, single_shifting = 0;
int c, c1, i, charset;
reg[0] = CHARSET_ASCII, reg[1] = reg[2] = reg[3] = -1;
switch (c)
{
case ISO_CODE_ESC:
+ single_shifting = 0;
if (src >= src_end)
break;
c = *src++;
/* Invalid designation sequence. Just ignore. */
break;
}
- else if (c == 'N' || c == 'n')
- {
- if (shift_out == 0
- && (reg[1] >= 0
- || SHIFT_OUT_OK (CODING_CATEGORY_IDX_ISO_7_ELSE)
- || SHIFT_OUT_OK (CODING_CATEGORY_IDX_ISO_8_ELSE)))
- {
- /* Locking shift out. */
- mask &= ~CODING_CATEGORY_MASK_ISO_7BIT;
- mask_found |= CODING_CATEGORY_MASK_ISO_SHIFT;
- shift_out = 1;
- }
- break;
- }
- else if (c == 'O' || c == 'o')
+ else if (c == 'N' || c == 'O')
{
- if (shift_out == 1)
- {
- /* Locking shift in. */
- mask &= ~CODING_CATEGORY_MASK_ISO_7BIT;
- mask_found |= CODING_CATEGORY_MASK_ISO_SHIFT;
- shift_out = 0;
- }
+ /* ESC <Fe> for SS2 or SS3. */
+ mask &= CODING_CATEGORY_MASK_ISO_7_ELSE;
break;
}
else if (c == '0' || c == '1' || c == '2')
- /* Start/end composition. Just ignore. */
+ /* ESC <Fp> for start/end composition. Just ignore. */
break;
else
/* Invalid escape sequence. Just ignore. */
mask_found |= CODING_CATEGORY_MASK_ISO_7_TIGHT;
else
mask &= ~CODING_CATEGORY_MASK_ISO_7_TIGHT;
- if (! CHARSET_OK (CODING_CATEGORY_IDX_ISO_7_ELSE, charset))
+ if (CHARSET_OK (CODING_CATEGORY_IDX_ISO_7_ELSE, charset))
+ mask_found |= CODING_CATEGORY_MASK_ISO_7_ELSE;
+ else
mask &= ~CODING_CATEGORY_MASK_ISO_7_ELSE;
- if (! CHARSET_OK (CODING_CATEGORY_IDX_ISO_8_ELSE, charset))
+ if (CHARSET_OK (CODING_CATEGORY_IDX_ISO_8_ELSE, charset))
+ mask_found |= CODING_CATEGORY_MASK_ISO_8_ELSE;
+ else
mask &= ~CODING_CATEGORY_MASK_ISO_8_ELSE;
break;
case ISO_CODE_SO:
+ single_shifting = 0;
if (shift_out == 0
&& (reg[1] >= 0
|| SHIFT_OUT_OK (CODING_CATEGORY_IDX_ISO_7_ELSE)
break;
case ISO_CODE_SI:
+ single_shifting = 0;
if (shift_out == 1)
{
/* Locking shift in. */
break;
case ISO_CODE_CSI:
+ single_shifting = 0;
case ISO_CODE_SS2:
case ISO_CODE_SS3:
{
if (coding_system_table[CODING_CATEGORY_IDX_ISO_8_2]->flags
& CODING_FLAG_ISO_SINGLE_SHIFT)
newmask |= CODING_CATEGORY_MASK_ISO_8_2;
+ single_shifting = 1;
}
if (VECTORP (Vlatin_extra_code_table)
&& !NILP (XVECTOR (Vlatin_extra_code_table)->contents[c]))
default:
if (c < 0x80)
- break;
+ {
+ single_shifting = 0;
+ break;
+ }
else if (c < 0xA0)
{
+ single_shifting = 0;
if (VECTORP (Vlatin_extra_code_table)
&& !NILP (XVECTOR (Vlatin_extra_code_table)->contents[c]))
{
mask &= ~(CODING_CATEGORY_MASK_ISO_7BIT
| CODING_CATEGORY_MASK_ISO_7_ELSE);
mask_found |= CODING_CATEGORY_MASK_ISO_8_1;
- while (src < src_end && *src >= 0xA0)
- src++;
- if ((src - src_begin - 1) & 1 && src < src_end)
- mask &= ~CODING_CATEGORY_MASK_ISO_8_2;
- else
- mask_found |= CODING_CATEGORY_MASK_ISO_8_2;
+ /* Check the length of succeeding codes of the range
+ 0xA0..0FF. If the byte length is odd, we exclude
+ CODING_CATEGORY_MASK_ISO_8_2. We can check this only
+ when we are not single shifting. */
+ if (!single_shifting)
+ {
+ while (src < src_end && *src >= 0xA0)
+ src++;
+ if ((src - src_begin - 1) & 1 && src < src_end)
+ mask &= ~CODING_CATEGORY_MASK_ISO_8_2;
+ else
+ mask_found |= CODING_CATEGORY_MASK_ISO_8_2;
+ }
}
break;
}
*dst++ = 0xFF; \
coding->composing += 2; \
} \
- if ((charset) >= 0) \
+ if (charset_alt >= 0) \
{ \
- if (CHARSET_DIMENSION (charset) == 2) \
+ if (CHARSET_DIMENSION (charset_alt) == 2) \
{ \
ONE_MORE_BYTE (c2); \
if (iso_code_class[(c2) & 0x7F] != ISO_0x20_or_0x7F \
&& iso_code_class[(c2) & 0x7F] != ISO_graphic_plane_0) \
{ \
src--; \
- c2 = ' '; \
+ charset_alt = CHARSET_ASCII; \
} \
} \
- if (!NILP (unification_table) \
- && ((c_alt = unify_char (unification_table, \
- -1, (charset), c1, c2)) >= 0)) \
+ if (!NILP (translation_table) \
+ && ((c_alt = translate_char (translation_table, \
+ -1, charset_alt, c1, c2)) >= 0)) \
SPLIT_CHAR (c_alt, charset_alt, c1, c2); \
} \
if (charset_alt == CHARSET_ASCII || charset_alt < 0) \
/* Set designation state into CODING. */
#define DECODE_DESIGNATION(reg, dimension, chars, final_char) \
do { \
- int charset = ISO_CHARSET_TABLE (make_number (dimension), \
- make_number (chars), \
- make_number (final_char)); \
+ int charset; \
+ \
+ if (final_char < '0' || final_char >= 128) \
+ goto label_invalid_code; \
+ charset = ISO_CHARSET_TABLE (make_number (dimension), \
+ make_number (chars), \
+ make_number (final_char)); \
if (charset >= 0 \
- && CODING_SPEC_ISO_REQUESTED_DESIGNATION (coding, charset) == reg) \
+ && (CODING_SPEC_ISO_REQUESTED_DESIGNATION (coding, charset) == reg \
+ || coding->safe_charsets[charset])) \
{ \
if (coding->spec.iso2022.last_invalid_designation_register == 0 \
&& reg == 0 \
} \
} while (0)
-/* Check if the current composing sequence contains only valid codes.
- If the composing sequence doesn't end before SRC_END, return -1.
- Else, if it contains only valid codes, return 0.
- Else return the length of the composing sequence. */
+/* Return 0 if there's a valid composing sequence starting at SRC and
+ ending before SRC_END, else return -1. */
-int check_composing_code (coding, src, src_end)
+int
+check_composing_code (coding, src, src_end)
struct coding_system *coding;
unsigned char *src, *src_end;
{
- unsigned char *src_start = src;
- int invalid_code_found = 0;
int charset, c, c1, dim;
while (src < src_end)
{
- if (*src++ != ISO_CODE_ESC) continue;
- if (src >= src_end) break;
- if ((c = *src++) == '1') /* end of compsition */
- return (invalid_code_found ? src - src_start : 0);
- if (src + 2 >= src_end) break;
- if (!coding->flags & CODING_FLAG_ISO_DESIGNATION)
- invalid_code_found = 1;
- else
+ c = *src++;
+ if (c >= 0x20)
+ continue;
+ if (c != ISO_CODE_ESC || src >= src_end)
+ return -1;
+ c = *src++;
+ if (c == '1') /* end of compsition */
+ return 0;
+ if (src + 2 >= src_end
+ || !coding->flags & CODING_FLAG_ISO_DESIGNATION)
+ return -1;
+
+ dim = (c == '$');
+ if (dim == 1)
+ c = (*src >= '@' && *src <= 'B') ? '(' : *src++;
+ if (c >= '(' && c <= '/')
{
- dim = 0;
- if (c == '$')
- {
- dim = 1;
- c = (*src >= '@' && *src <= 'B') ? '(' : *src++;
- }
- if (c >= '(' && c <= '/')
- {
- c1 = *src++;
- if ((c1 < ' ' || c1 >= 0x80)
- || (charset = iso_charset_table[dim][c >= ','][c1]) < 0
- || (CODING_SPEC_ISO_REQUESTED_DESIGNATION (coding, charset)
- == CODING_SPEC_ISO_NO_REQUESTED_DESIGNATION))
- invalid_code_found = 1;
- }
- else
- invalid_code_found = 1;
+ c1 = *src++;
+ if ((c1 < ' ' || c1 >= 0x80)
+ || (charset = iso_charset_table[dim][c >= ','][c1]) < 0
+ || ! coding->safe_charsets[charset]
+ || (CODING_SPEC_ISO_REQUESTED_DESIGNATION (coding, charset)
+ == CODING_SPEC_ISO_NO_REQUESTED_DESIGNATION))
+ return -1;
}
+ else
+ return -1;
}
- return ((coding->mode & CODING_MODE_LAST_BLOCK) ? src_end - src_start : -1);
+
+ /* We have not found the sequence "ESC 1". */
+ return -1;
}
/* See the above "GENERAL NOTES on `decode_coding_XXX ()' functions". */
/* Charsets invoked to graphic plane 0 and 1 respectively. */
int charset0 = CODING_SPEC_ISO_PLANE_CHARSET (coding, 0);
int charset1 = CODING_SPEC_ISO_PLANE_CHARSET (coding, 1);
- Lisp_Object unification_table
- = coding->character_unification_table_for_decode;
+ Lisp_Object translation_table
+ = coding->translation_table_for_decode;
int result = CODING_FINISH_NORMAL;
- if (!NILP (Venable_character_unification) && NILP (unification_table))
- unification_table = Vstandard_character_unification_table_for_decode;
+ if (!NILP (Venable_character_translation) && NILP (translation_table))
+ translation_table = Vstandard_translation_table_for_decode;
coding->produced_char = 0;
+ coding->fake_multibyte = 0;
while (src < src_end && (dst_bytes
? (dst < adjusted_dst_end)
: (dst < src - 6)))
case ISO_0xA0_or_0xFF:
if (charset1 < 0 || CHARSET_CHARS (charset1) == 94
|| coding->flags & CODING_FLAG_ISO_SEVEN_BITS)
- {
- /* Invalid code. */
- *dst++ = c1;
- coding->produced_char++;
- break;
- }
+ goto label_invalid_code;
/* This is a graphic character, we fall down ... */
case ISO_graphic_plane_1:
if (coding->flags & CODING_FLAG_ISO_SEVEN_BITS)
- {
- /* Invalid code. */
- *dst++ = c1;
- coding->produced_char++;
- }
+ goto label_invalid_code;
else
DECODE_ISO_CHARACTER (charset1, c1);
break;
}
*dst++ = c1;
coding->produced_char++;
+ if (c1 >= 0x80)
+ coding->fake_multibyte = 1;
break;
case ISO_carriage_return:
ONE_MORE_BYTE (c1);
if (c1 >= '@' && c1 <= 'B')
{ /* designation of JISX0208.1978, GB2312.1980,
- or JISX0208.1980 */
+ or JISX0208.1980 */
DECODE_DESIGNATION (0, 2, 94, c1);
}
else if (c1 >= 0x28 && c1 <= 0x2B)
case '0': case '2': /* start composing */
/* Before processing composing, we must be sure that all
characters being composed are supported by CODING.
- If not, we must give up composing and insert the
- bunch of codes for composing as is without decoding. */
- {
- int result1;
-
- result1 = check_composing_code (coding, src, src_end);
- if (result1 == 0)
+ If not, we must give up composing. */
+ if (check_composing_code (coding, src, src_end) == 0)
+ {
+ /* We are looking at a valid composition sequence. */
coding->composing = (c1 == '0'
? COMPOSING_NO_RULE_HEAD
: COMPOSING_WITH_RULE_HEAD);
- else if (result1 > 0)
- {
- if (result1 + 2 < (dst_bytes ? dst_end : src_base) - dst)
- {
- bcopy (src_base, dst, result1 + 2);
- src += result1;
- dst += result1 + 2;
- coding->produced_char += result1 + 2;
- }
- else
- {
- result = CODING_FINISH_INSUFFICIENT_DST;
- goto label_end_of_loop_2;
- }
- }
- else
- goto label_end_of_loop;
- }
+ coding->composed_chars = 0;
+ }
+ else
+ {
+ *dst++ = ISO_CODE_ESC;
+ *dst++ = c1;
+ coding->produced_char += 2;
+ }
break;
case '1': /* end composing */
+ if (!coding->composing)
+ {
+ *dst++ = ISO_CODE_ESC;
+ *dst++ = c1;
+ coding->produced_char += 2;
+ break;
+ }
+
+ if (coding->composed_chars > 0)
+ {
+ if (coding->composed_chars == 1)
+ {
+ unsigned char *this_char_start = dst;
+ int this_bytes;
+
+ /* Only one character is in the composing
+ sequence. Make it a normal character. */
+ while (*--this_char_start != LEADING_CODE_COMPOSITION);
+ dst = (this_char_start
+ + (coding->composing == COMPOSING_NO_RULE_TAIL
+ ? 1 : 2));
+ *dst -= 0x20;
+ if (*dst == 0x80)
+ *++dst &= 0x7F;
+ this_bytes = BYTES_BY_CHAR_HEAD (*dst);
+ while (this_bytes--) *this_char_start++ = *dst++;
+ dst = this_char_start;
+ }
+ coding->produced_char++;
+ }
coding->composing = COMPOSING_NO;
- coding->produced_char++;
break;
case '[': /* specification of direction */
break;
label_invalid_code:
- coding->produced_char += src - src_base;
while (src_base < src)
*dst++ = *src_base++;
+ coding->fake_multibyte = 1;
}
continue;
break;
}
- if (result == CODING_FINISH_NORMAL
- && src < src_end)
- result = CODING_FINISH_INSUFFICIENT_DST;
-
- /* If this is the last block of the text to be decoded, we had
- better just flush out all remaining codes in the text although
- they are not valid characters. */
- if (coding->mode & CODING_MODE_LAST_BLOCK)
+ if (src < src_end)
{
- bcopy (src, dst, src_end - src);
- dst += (src_end - src);
- src = src_end;
+ if (result == CODING_FINISH_NORMAL)
+ result = CODING_FINISH_INSUFFICIENT_DST;
+ else if (result != CODING_FINISH_INCONSISTENT_EOL
+ && coding->mode & CODING_MODE_LAST_BLOCK)
+ {
+ /* This is the last block of the text to be decoded. We had
+ better just flush out all remaining codes in the text
+ although they are not valid characters. */
+ src_bytes = src_end - src;
+ if (dst_bytes && (dst_end - dst < src_bytes))
+ src_bytes = dst_end - dst;
+ bcopy (src, dst, src_bytes);
+ dst += src_bytes;
+ src += src_bytes;
+ coding->fake_multibyte = 1;
+ }
}
+
coding->consumed = coding->consumed_char = src - source;
coding->produced = dst - destination;
return result;
if (coding->flags & CODING_FLAG_ISO_SEVEN_BITS) \
*dst++ = ISO_CODE_ESC, *dst++ = 'N'; \
else \
- *dst++ = ISO_CODE_SS2; \
+ { \
+ *dst++ = ISO_CODE_SS2; \
+ coding->fake_multibyte = 1; \
+ } \
CODING_SPEC_ISO_SINGLE_SHIFTING (coding) = 1; \
} while (0)
-#define ENCODE_SINGLE_SHIFT_3 \
- do { \
+#define ENCODE_SINGLE_SHIFT_3 \
+ do { \
if (coding->flags & CODING_FLAG_ISO_SEVEN_BITS) \
- *dst++ = ISO_CODE_ESC, *dst++ = 'O'; \
- else \
- *dst++ = ISO_CODE_SS3; \
+ *dst++ = ISO_CODE_ESC, *dst++ = 'O'; \
+ else \
+ { \
+ *dst++ = ISO_CODE_SS3; \
+ coding->fake_multibyte = 1; \
+ } \
CODING_SPEC_ISO_SINGLE_SHIFTING (coding) = 1; \
} while (0)
dst = encode_invocation_designation (charset, coding, dst); \
} while (1)
-#define ENCODE_ISO_CHARACTER(charset, c1, c2) \
- do { \
- int c_alt, charset_alt; \
- if (!NILP (unification_table) \
- && ((c_alt = unify_char (unification_table, -1, charset, c1, c2)) \
- >= 0)) \
- SPLIT_CHAR (c_alt, charset_alt, c1, c2); \
- else \
- charset_alt = charset; \
- if (CHARSET_DIMENSION (charset_alt) == 1) \
- ENCODE_ISO_CHARACTER_DIMENSION1 (charset_alt, c1); \
- else \
- ENCODE_ISO_CHARACTER_DIMENSION2 (charset_alt, c1, c2); \
- if (! COMPOSING_P (coding->composing)) \
- coding->consumed_char++; \
+#define ENCODE_ISO_CHARACTER(charset, c1, c2) \
+ do { \
+ int c_alt, charset_alt; \
+ if (!NILP (translation_table) \
+ && ((c_alt = translate_char (translation_table, -1, \
+ charset, c1, c2)) \
+ >= 0)) \
+ SPLIT_CHAR (c_alt, charset_alt, c1, c2); \
+ else \
+ charset_alt = charset; \
+ if (CHARSET_DEFINED_P (charset_alt)) \
+ { \
+ if (CHARSET_DIMENSION (charset_alt) == 1) \
+ { \
+ if (charset == CHARSET_ASCII \
+ && coding->flags & CODING_FLAG_ISO_USE_ROMAN) \
+ charset_alt = charset_latin_jisx0201; \
+ ENCODE_ISO_CHARACTER_DIMENSION1 (charset_alt, c1); \
+ } \
+ else \
+ { \
+ if (charset == charset_jisx0208 \
+ && coding->flags & CODING_FLAG_ISO_USE_OLDJIS) \
+ charset_alt = charset_jisx0208_1978; \
+ ENCODE_ISO_CHARACTER_DIMENSION2 (charset_alt, c1, c2); \
+ } \
+ } \
+ else \
+ { \
+ if (coding->flags & CODING_FLAG_ISO_SEVEN_BITS) \
+ { \
+ *dst++ = charset & 0x7f; \
+ *dst++ = c1 & 0x7f; \
+ if (c2) \
+ *dst++ = c2 & 0x7f; \
+ } \
+ else \
+ { \
+ *dst++ = charset; \
+ *dst++ = c1; \
+ if (c2) \
+ *dst++ = c2; \
+ } \
+ } \
+ if (! COMPOSING_P (coding->composing)) \
+ coding->consumed_char++; \
} while (0)
/* Produce designation and invocation codes at a place pointed by DST
If the current block ends before any end-of-line, we may fail to
find all the necessary designations. */
+void
encode_designation_at_bol (coding, table, src, src_end, dstp)
struct coding_system *coding;
Lisp_Object table;
unsigned char c1, c2;
SPLIT_STRING(src, bytes, charset, c1, c2);
- if ((c_alt = unify_char (table, -1, charset, c1, c2)) >= 0)
+ if ((c_alt = translate_char (table, -1, charset, c1, c2)) >= 0)
charset = CHAR_CHARSET (c_alt);
}
from DST_END to assure overflow checking is necessary only at the
head of loop. */
unsigned char *adjusted_dst_end = dst_end - 19;
- Lisp_Object unification_table
- = coding->character_unification_table_for_encode;
+ Lisp_Object translation_table
+ = coding->translation_table_for_encode;
int result = CODING_FINISH_NORMAL;
- if (!NILP (Venable_character_unification) && NILP (unification_table))
- unification_table = Vstandard_character_unification_table_for_encode;
+ if (!NILP (Venable_character_translation) && NILP (translation_table))
+ translation_table = Vstandard_translation_table_for_encode;
coding->consumed_char = 0;
+ coding->fake_multibyte = 0;
while (src < src_end && (dst_bytes
? (dst < adjusted_dst_end)
: (dst < src - 19)))
&& CODING_SPEC_ISO_BOL (coding))
{
/* We have to produce designation sequences if any now. */
- encode_designation_at_bol (coding, unification_table,
+ encode_designation_at_bol (coding, translation_table,
src, src_end, &dst);
CODING_SPEC_ISO_BOL (coding) = 0;
}
switch (emacs_code_class[c1])
{
case EMACS_ascii_code:
+ c2 = 0;
ENCODE_ISO_CHARACTER (CHARSET_ASCII, c1, /* dummy */ c2);
break;
case EMACS_leading_code_2:
ONE_MORE_BYTE (c2);
+ c3 = 0;
if (c2 < 0xA0)
{
/* invalid sequence */
*dst++ = c1;
- *dst++ = c2;
- coding->consumed_char += 2;
+ src--;
+ coding->consumed_char++;
}
else
ENCODE_ISO_CHARACTER (c1, c2, /* dummy */ c3);
case EMACS_leading_code_3:
TWO_MORE_BYTES (c2, c3);
+ c4 = 0;
if (c2 < 0xA0 || c3 < 0xA0)
{
/* invalid sequence */
*dst++ = c1;
- *dst++ = c2;
- *dst++ = c3;
- coding->consumed_char += 3;
+ src -= 2;
+ coding->consumed_char++;
}
else if (c1 < LEADING_CODE_PRIVATE_11)
ENCODE_ISO_CHARACTER (c1, c2, c3);
{
/* invalid sequence */
*dst++ = c1;
- *dst++ = c2;
- *dst++ = c3;
- *dst++ = c4;
- coding->consumed_char += 4;
+ src -= 3;
+ coding->consumed_char++;
}
else
ENCODE_ISO_CHARACTER (c2, c3, c4);
{
/* invalid sequence */
*dst++ = c1;
- *dst++ = c2;
- coding->consumed_char += 2;
+ src--;
+ coding->consumed_char++;
}
else if (c2 == 0xFF)
{
break;
case EMACS_invalid_code:
+ if (coding->flags & CODING_FLAG_ISO_RESET_AT_CNTL)
+ ENCODE_RESET_PLANE_AND_REGISTER;
*dst++ = c1;
coding->consumed_char++;
break;
break;
}
- if (result == CODING_FINISH_NORMAL
- && src < src_end)
+ if (src < src_end && result == CODING_FINISH_NORMAL)
result = CODING_FINISH_INSUFFICIENT_DST;
/* If this is the last block of the text to be encoded, we must
reset graphic planes and registers to the initial state, and
flush out the carryover if any. */
if (coding->mode & CODING_MODE_LAST_BLOCK)
- ENCODE_RESET_PLANE_AND_REGISTER;
-
+ {
+ ENCODE_RESET_PLANE_AND_REGISTER;
+ if (COMPOSING_P (coding->composing))
+ ENCODE_COMPOSITION_END;
+ if (result == CODING_FINISH_INSUFFICIENT_SRC)
+ {
+ while (src < src_end && dst < dst_end)
+ *dst++ = *src++;
+ }
+ }
coding->consumed = src - source;
coding->produced = coding->produced_char = dst - destination;
return result;
(character set) (range)
ASCII 0x00 .. 0x7F
KATAKANA-JISX0201 0xA0 .. 0xDF
- JISX0208 (1st byte) 0x80 .. 0x9F and 0xE0 .. 0xFF
- (2nd byte) 0x40 .. 0xFF
+ JISX0208 (1st byte) 0x81 .. 0x9F and 0xE0 .. 0xEF
+ (2nd byte) 0x40 .. 0x7E and 0x80 .. 0xFC
-------------------------------
*/
#define DECODE_SJIS_BIG5_CHARACTER(charset, c1, c2) \
do { \
int c_alt, charset_alt = (charset); \
- if (!NILP (unification_table) \
- && ((c_alt = unify_char (unification_table, \
- -1, (charset), c1, c2)) >= 0)) \
- SPLIT_CHAR (c_alt, charset_alt, c1, c2); \
+ if (!NILP (translation_table) \
+ && ((c_alt = translate_char (translation_table, \
+ -1, (charset), c1, c2)) >= 0)) \
+ SPLIT_CHAR (c_alt, charset_alt, c1, c2); \
if (charset_alt == CHARSET_ASCII || charset_alt < 0) \
DECODE_CHARACTER_ASCII (c1); \
else if (CHARSET_DIMENSION (charset_alt) == 1) \
DECODE_CHARACTER_DIMENSION1 (charset_alt, c1); \
else \
DECODE_CHARACTER_DIMENSION2 (charset_alt, c1, c2); \
- coding->produced_char++; \
} while (0)
-#define ENCODE_SJIS_BIG5_CHARACTER(charset, c1, c2) \
- do { \
- int c_alt, charset_alt; \
- if (!NILP (unification_table) \
- && ((c_alt = unify_char (unification_table, -1, charset, c1, c2)) \
- >= 0)) \
- SPLIT_CHAR (c_alt, charset_alt, c1, c2); \
- else \
- charset_alt = charset; \
- if (charset_alt == charset_ascii) \
- *dst++ = c1; \
- else if (CHARSET_DIMENSION (charset_alt) == 1) \
- { \
- if (sjis_p && charset_alt == charset_katakana_jisx0201) \
- *dst++ = c1; \
- else \
- *dst++ = charset_alt, *dst++ = c1; \
- } \
- else \
- { \
- c1 &= 0x7F, c2 &= 0x7F; \
- if (sjis_p && charset_alt == charset_jisx0208) \
- { \
- unsigned char s1, s2; \
- \
- ENCODE_SJIS (c1, c2, s1, s2); \
- *dst++ = s1, *dst++ = s2; \
- } \
- else if (!sjis_p \
- && (charset_alt == charset_big5_1 \
- || charset_alt == charset_big5_2)) \
- { \
- unsigned char b1, b2; \
- \
- ENCODE_BIG5 (charset_alt, c1, c2, b1, b2); \
- *dst++ = b1, *dst++ = b2; \
- } \
- else \
- *dst++ = charset_alt, *dst++ = c1, *dst++ = c2; \
- } \
- coding->consumed_char++; \
+#define ENCODE_SJIS_BIG5_CHARACTER(charset, c1, c2) \
+ do { \
+ int c_alt, charset_alt; \
+ if (!NILP (translation_table) \
+ && ((c_alt = translate_char (translation_table, -1, \
+ charset, c1, c2)) \
+ >= 0)) \
+ SPLIT_CHAR (c_alt, charset_alt, c1, c2); \
+ else \
+ charset_alt = charset; \
+ if (charset_alt == charset_ascii) \
+ *dst++ = c1; \
+ else if (CHARSET_DIMENSION (charset_alt) == 1) \
+ { \
+ if (sjis_p && charset_alt == charset_katakana_jisx0201) \
+ *dst++ = c1; \
+ else if (sjis_p && charset_alt == charset_latin_jisx0201) \
+ *dst++ = c1 & 0x7F; \
+ else \
+ { \
+ *dst++ = charset_alt, *dst++ = c1; \
+ coding->fake_multibyte = 1; \
+ } \
+ } \
+ else \
+ { \
+ c1 &= 0x7F, c2 &= 0x7F; \
+ if (sjis_p && (charset_alt == charset_jisx0208 \
+ || charset_alt == charset_jisx0208_1978))\
+ { \
+ unsigned char s1, s2; \
+ \
+ ENCODE_SJIS (c1, c2, s1, s2); \
+ *dst++ = s1, *dst++ = s2; \
+ coding->fake_multibyte = 1; \
+ } \
+ else if (!sjis_p \
+ && (charset_alt == charset_big5_1 \
+ || charset_alt == charset_big5_2)) \
+ { \
+ unsigned char b1, b2; \
+ \
+ ENCODE_BIG5 (charset_alt, c1, c2, b1, b2); \
+ *dst++ = b1, *dst++ = b2; \
+ } \
+ else \
+ { \
+ *dst++ = charset_alt, *dst++ = c1, *dst++ = c2; \
+ coding->fake_multibyte = 1; \
+ } \
+ } \
+ coding->consumed_char++; \
} while (0);
/* See the above "GENERAL NOTES on `detect_coding_XXX ()' functions".
from DST_END to assure overflow checking is necessary only at the
head of loop. */
unsigned char *adjusted_dst_end = dst_end - 3;
- Lisp_Object unification_table
- = coding->character_unification_table_for_decode;
+ Lisp_Object translation_table
+ = coding->translation_table_for_decode;
int result = CODING_FINISH_NORMAL;
- if (!NILP (Venable_character_unification) && NILP (unification_table))
- unification_table = Vstandard_character_unification_table_for_decode;
+ if (!NILP (Venable_character_translation) && NILP (translation_table))
+ translation_table = Vstandard_translation_table_for_decode;
coding->produced_char = 0;
+ coding->fake_multibyte = 0;
while (src < src_end && (dst_bytes
? (dst < adjusted_dst_end)
: (dst < src - 3)))
coding->produced_char++;
}
else if (c1 < 0x80)
- DECODE_SJIS_BIG5_CHARACTER (charset_ascii, c1, /* dummy */ c2);
- else if (c1 < 0xA0 || c1 >= 0xE0)
+ {
+ c2 = 0; /* avoid warning */
+ DECODE_SJIS_BIG5_CHARACTER (charset_ascii, c1, /* dummy */ c2);
+ }
+ else
{
- /* SJIS -> JISX0208, BIG5 -> Big5 (only if 0xE0 <= c1 < 0xFF) */
if (sjis_p)
{
- ONE_MORE_BYTE (c2);
- DECODE_SJIS (c1, c2, c3, c4);
- DECODE_SJIS_BIG5_CHARACTER (charset_jisx0208, c3, c4);
- }
- else if (c1 >= 0xE0 && c1 < 0xFF)
- {
- int charset;
-
- ONE_MORE_BYTE (c2);
- DECODE_BIG5 (c1, c2, charset, c3, c4);
- DECODE_SJIS_BIG5_CHARACTER (charset, c3, c4);
- }
- else /* Invalid code */
- {
- *dst++ = c1;
- coding->produced_char++;
+ if (c1 < 0xA0 || (c1 >= 0xE0 && c1 < 0xF0))
+ {
+ /* SJIS -> JISX0208 */
+ ONE_MORE_BYTE (c2);
+ if (c2 >= 0x40 && c2 != 0x7F && c2 <= 0xFC)
+ {
+ DECODE_SJIS (c1, c2, c3, c4);
+ DECODE_SJIS_BIG5_CHARACTER (charset_jisx0208, c3, c4);
+ }
+ else
+ goto label_invalid_code_2;
+ }
+ else if (c1 < 0xE0)
+ /* SJIS -> JISX0201-Kana */
+ {
+ c2 = 0; /* avoid warning */
+ DECODE_SJIS_BIG5_CHARACTER (charset_katakana_jisx0201, c1,
+ /* dummy */ c2);
+ }
+ else
+ goto label_invalid_code_1;
}
- }
- else
- {
- /* SJIS -> JISX0201-Kana, BIG5 -> Big5 */
- if (sjis_p)
- DECODE_SJIS_BIG5_CHARACTER (charset_katakana_jisx0201, c1,
- /* dummy */ c2);
else
{
- int charset;
+ /* BIG5 -> Big5 */
+ if (c1 >= 0xA1 && c1 <= 0xFE)
+ {
+ ONE_MORE_BYTE (c2);
+ if ((c2 >= 0x40 && c2 <= 0x7E) || (c2 >= 0xA1 && c2 <= 0xFE))
+ {
+ int charset;
- ONE_MORE_BYTE (c2);
- DECODE_BIG5 (c1, c2, charset, c3, c4);
- DECODE_SJIS_BIG5_CHARACTER (charset, c3, c4);
+ DECODE_BIG5 (c1, c2, charset, c3, c4);
+ DECODE_SJIS_BIG5_CHARACTER (charset, c3, c4);
+ }
+ else
+ goto label_invalid_code_2;
+ }
+ else
+ goto label_invalid_code_1;
}
}
continue;
+ label_invalid_code_1:
+ *dst++ = c1;
+ coding->produced_char++;
+ coding->fake_multibyte = 1;
+ continue;
+
+ label_invalid_code_2:
+ *dst++ = c1; *dst++= c2;
+ coding->produced_char += 2;
+ coding->fake_multibyte = 1;
+ continue;
+
label_end_of_loop:
result = CODING_FINISH_INSUFFICIENT_SRC;
label_end_of_loop_2:
break;
}
- if (result == CODING_FINISH_NORMAL
- && src < src_end)
- result = CODING_FINISH_INSUFFICIENT_DST;
+ if (src < src_end)
+ {
+ if (result == CODING_FINISH_NORMAL)
+ result = CODING_FINISH_INSUFFICIENT_DST;
+ else if (result != CODING_FINISH_INCONSISTENT_EOL
+ && coding->mode & CODING_MODE_LAST_BLOCK)
+ {
+ src_bytes = src_end - src;
+ if (dst_bytes && (dst_end - dst < src_bytes))
+ src_bytes = dst_end - dst;
+ bcopy (dst, src, src_bytes);
+ src += src_bytes;
+ dst += src_bytes;
+ coding->fake_multibyte = 1;
+ }
+ }
coding->consumed = coding->consumed_char = src - source;
coding->produced = dst - destination;
from DST_END to assure overflow checking is necessary only at the
head of loop. */
unsigned char *adjusted_dst_end = dst_end - 1;
- Lisp_Object unification_table
- = coding->character_unification_table_for_encode;
+ Lisp_Object translation_table
+ = coding->translation_table_for_encode;
int result = CODING_FINISH_NORMAL;
- if (!NILP (Venable_character_unification) && NILP (unification_table))
- unification_table = Vstandard_character_unification_table_for_encode;
+ if (!NILP (Venable_character_translation) && NILP (translation_table))
+ translation_table = Vstandard_translation_table_for_encode;
coding->consumed_char = 0;
+ coding->fake_multibyte = 0;
while (src < src_end && (dst_bytes
? (dst < adjusted_dst_end)
: (dst < src - 1)))
}
\f
-/*** 5. End-of-line handlers ***/
+/*** 5. CCL handlers ***/
+
+/* See the above "GENERAL NOTES on `detect_coding_XXX ()' functions".
+ Check if a text is encoded in a coding system of which
+ encoder/decoder are written in CCL program. If it is, return
+ CODING_CATEGORY_MASK_CCL, else return 0. */
+
+int
+detect_coding_ccl (src, src_end)
+ unsigned char *src, *src_end;
+{
+ unsigned char *valid;
+
+ /* No coding system is assigned to coding-category-ccl. */
+ if (!coding_system_table[CODING_CATEGORY_IDX_CCL])
+ return 0;
+
+ valid = coding_system_table[CODING_CATEGORY_IDX_CCL]->spec.ccl.valid_codes;
+ while (src < src_end)
+ {
+ if (! valid[*src]) return 0;
+ src++;
+ }
+ return CODING_CATEGORY_MASK_CCL;
+}
+
+\f
+/*** 6. End-of-line handlers ***/
/* See the above "GENERAL NOTES on `decode_coding_XXX ()' functions".
This function is called only when `coding->eol_type' is
CODING_EOL_CRLF or CODING_EOL_CR. */
+int
decode_eol (coding, source, destination, src_bytes, dst_bytes)
struct coding_system *coding;
unsigned char *source, *destination;
unsigned char *src_end = source + src_bytes;
unsigned char *dst = destination;
unsigned char *dst_end = destination + dst_bytes;
+ unsigned char c;
int result = CODING_FINISH_NORMAL;
+ coding->fake_multibyte = 0;
+
if (src_bytes <= 0)
- return result;
+ {
+ coding->produced = coding->produced_char = 0;
+ coding->consumed = coding->consumed_char = 0;
+ return result;
+ }
switch (coding->eol_type)
{
: (dst < src - 1)))
{
unsigned char *src_base = src;
- unsigned char c = *src++;
+
+ c = *src++;
if (c == '\r')
{
ONE_MORE_BYTE (c);
- if (c != '\n')
+ if (c == '\n')
+ *dst++ = c;
+ else
{
if (coding->mode & CODING_MODE_INHIBIT_INCONSISTENT_EOL)
{
result = CODING_FINISH_INCONSISTENT_EOL;
goto label_end_of_loop_2;
}
+ src--;
*dst++ = '\r';
+ if (BASE_LEADING_CODE_P (c))
+ coding->fake_multibyte = 1;
}
- *dst++ = c;
}
else if (c == '\n'
&& (coding->mode & CODING_MODE_INHIBIT_INCONSISTENT_EOL))
goto label_end_of_loop_2;
}
else
- *dst++ = c;
+ {
+ *dst++ = c;
+ if (BASE_LEADING_CODE_P (c))
+ coding->fake_multibyte = 1;
+ }
continue;
label_end_of_loop:
src = src_base;
break;
}
- if (result == CODING_FINISH_NORMAL
- && src < src_end)
- result = CODING_FINISH_INSUFFICIENT_DST;
+ if (src < src_end)
+ {
+ if (result == CODING_FINISH_NORMAL)
+ result = CODING_FINISH_INSUFFICIENT_DST;
+ else if (result != CODING_FINISH_INCONSISTENT_EOL
+ && coding->mode & CODING_MODE_LAST_BLOCK)
+ {
+ /* This is the last block of the text to be decoded.
+ We flush out all remaining codes. */
+ src_bytes = src_end - src;
+ if (dst_bytes && (dst_end - dst < src_bytes))
+ src_bytes = dst_end - dst;
+ bcopy (src, dst, src_bytes);
+ dst += src_bytes;
+ src += src_bytes;
+ }
+ }
}
break;
case CODING_EOL_CR:
if (coding->mode & CODING_MODE_INHIBIT_INCONSISTENT_EOL)
{
- while (src < src_end) if (*src++ == '\n') break;
+ while (src < src_end)
+ {
+ if ((c = *src++) == '\n')
+ break;
+ if (BASE_LEADING_CODE_P (c))
+ coding->fake_multibyte = 1;
+ }
if (*--src == '\n')
{
src_bytes = src - source;
else
safe_bcopy (source, destination, src_bytes);
src += src_bytes;
- dst += dst_bytes;
+ dst += src_bytes;
+ coding->fake_multibyte = 1;
break;
}
`coding->mode & CODING_MODE_SELECTIVE_DISPLAY' is nonzero, code
'\r' in source text also means end-of-line. */
+int
encode_eol (coding, source, destination, src_bytes, dst_bytes)
struct coding_system *coding;
unsigned char *source, *destination;
unsigned char *dst = destination;
int result = CODING_FINISH_NORMAL;
+ coding->fake_multibyte = 0;
+
if (coding->eol_type == CODING_EOL_CRLF)
{
unsigned char c;
|| (c == '\r' && (coding->mode & CODING_MODE_SELECTIVE_DISPLAY)))
*dst++ = '\r', *dst++ = '\n';
else
- *dst++ = c;
+ {
+ *dst++ = c;
+ if (BASE_LEADING_CODE_P (c))
+ coding->fake_multibyte = 1;
+ }
}
if (src < src_end)
result = CODING_FINISH_INSUFFICIENT_DST;
}
else
{
+ unsigned char c;
+
if (dst_bytes && src_bytes > dst_bytes)
{
src_bytes = dst_bytes;
bcopy (source, destination, src_bytes);
else
safe_bcopy (source, destination, src_bytes);
- if (coding->eol_type == CODING_EOL_CRLF)
+ dst_bytes = src_bytes;
+ if (coding->eol_type == CODING_EOL_CR)
{
while (src_bytes--)
- if (*dst++ == '\n') dst[-1] = '\r';
+ {
+ if ((c = *dst++) == '\n')
+ dst[-1] = '\r';
+ else if (BASE_LEADING_CODE_P (c))
+ coding->fake_multibyte = 1;
+ }
}
- else if (coding->mode & CODING_MODE_SELECTIVE_DISPLAY)
+ else
{
- while (src_bytes--)
- if (*dst++ == '\r') dst[-1] = '\n';
+ if (coding->mode & CODING_MODE_SELECTIVE_DISPLAY)
+ {
+ while (src_bytes--)
+ if (*dst++ == '\r') dst[-1] = '\n';
+ }
+ coding->fake_multibyte = 1;
}
- src += src_bytes;
- dst += src_bytes;
+ src = source + dst_bytes;
+ dst = destination + dst_bytes;
}
coding->consumed = coding->consumed_char = src - source;
}
\f
-/*** 6. C library functions ***/
+/*** 7. C library functions ***/
/* In Emacs Lisp, coding system is represented by a Lisp symbol which
has a property `coding-system'. The value of this property is a
coding->mode = 0;
coding->heading_ascii = -1;
coding->post_read_conversion = coding->pre_write_conversion = Qnil;
+
+ if (NILP (coding_system))
+ goto label_invalid_coding_system;
+
coding_spec = Fget (coding_system, Qcoding_system);
+
if (!VECTORP (coding_spec)
|| XVECTOR (coding_spec)->size != 5
|| !CONSP (XVECTOR (coding_spec)->contents[3]))
/* Initialize remaining fields. */
coding->composing = 0;
- coding->character_unification_table_for_decode = Qnil;
- coding->character_unification_table_for_encode = Qnil;
+ coding->composed_chars = 0;
/* Get values of coding system properties:
`post-read-conversion', `pre-write-conversion',
- `character-unification-table-for-decode',
- `character-unification-table-for-encode'. */
+ `translation-table-for-decode', `translation-table-for-encode'. */
plist = XVECTOR (coding_spec)->contents[3];
coding->post_read_conversion = Fplist_get (plist, Qpost_read_conversion);
coding->pre_write_conversion = Fplist_get (plist, Qpre_write_conversion);
- val = Fplist_get (plist, Qcharacter_unification_table_for_decode);
+ val = Fplist_get (plist, Qtranslation_table_for_decode);
if (SYMBOLP (val))
- val = Fget (val, Qcharacter_unification_table_for_decode);
- coding->character_unification_table_for_decode
- = CHAR_TABLE_P (val) ? val : Qnil;
- val = Fplist_get (plist, Qcharacter_unification_table_for_encode);
+ val = Fget (val, Qtranslation_table_for_decode);
+ coding->translation_table_for_decode = CHAR_TABLE_P (val) ? val : Qnil;
+ val = Fplist_get (plist, Qtranslation_table_for_encode);
if (SYMBOLP (val))
- val = Fget (val, Qcharacter_unification_table_for_encode);
- coding->character_unification_table_for_encode
- = CHAR_TABLE_P (val) ? val : Qnil;
+ val = Fget (val, Qtranslation_table_for_encode);
+ coding->translation_table_for_encode = CHAR_TABLE_P (val) ? val : Qnil;
val = Fplist_get (plist, Qcoding_category);
if (!NILP (val))
{
bzero (coding->safe_charsets, MAX_CHARSET + 1);
while (CONSP (val))
{
- if ((i = get_charset_id (XCONS (val)->car)) >= 0)
+ if ((i = get_charset_id (XCAR (val))) >= 0)
coding->safe_charsets[i] = 1;
- val = XCONS (val)->cdr;
+ val = XCDR (val);
}
}
val = Vcharset_revision_alist;
while (CONSP (val))
{
- charset = get_charset_id (Fcar_safe (XCONS (val)->car));
+ charset = get_charset_id (Fcar_safe (XCAR (val)));
if (charset >= 0
- && (temp = Fcdr_safe (XCONS (val)->car), INTEGERP (temp))
+ && (temp = Fcdr_safe (XCAR (val)), INTEGERP (temp))
&& (i = XINT (temp), (i >= 0 && (i + '@') < 128)))
CODING_SPEC_ISO_REVISION_NUMBER (coding, charset) = i;
- val = XCONS (val)->cdr;
+ val = XCDR (val);
}
/* Checks FLAGS[REG] (REG = 0, 1, 2 3) and decide designations.
}
else if (CONSP (flags[i]))
{
- Lisp_Object tail = flags[i];
+ Lisp_Object tail;
+ tail = flags[i];
coding->flags |= CODING_FLAG_ISO_DESIGNATION;
- if (INTEGERP (XCONS (tail)->car)
- && (charset = XINT (XCONS (tail)->car),
+ if (INTEGERP (XCAR (tail))
+ && (charset = XINT (XCAR (tail)),
CHARSET_VALID_P (charset))
- || (charset = get_charset_id (XCONS (tail)->car)) >= 0)
+ || (charset = get_charset_id (XCAR (tail))) >= 0)
{
CODING_SPEC_ISO_INITIAL_DESIGNATION (coding, i) = charset;
CODING_SPEC_ISO_REQUESTED_DESIGNATION (coding, charset) =i;
}
else
CODING_SPEC_ISO_INITIAL_DESIGNATION (coding, i) = -1;
- tail = XCONS (tail)->cdr;
+ tail = XCDR (tail);
while (CONSP (tail))
{
- if (INTEGERP (XCONS (tail)->car)
- && (charset = XINT (XCONS (tail)->car),
+ if (INTEGERP (XCAR (tail))
+ && (charset = XINT (XCAR (tail)),
CHARSET_VALID_P (charset))
- || (charset = get_charset_id (XCONS (tail)->car)) >= 0)
+ || (charset = get_charset_id (XCAR (tail))) >= 0)
CODING_SPEC_ISO_REQUESTED_DESIGNATION (coding, charset)
= i;
- else if (EQ (XCONS (tail)->car, Qt))
+ else if (EQ (XCAR (tail), Qt))
reg_bits |= 1 << i;
- tail = XCONS (tail)->cdr;
+ tail = XCDR (tail);
}
}
else
coding->common_flags
|= CODING_REQUIRE_DECODING_MASK | CODING_REQUIRE_ENCODING_MASK;
{
- Lisp_Object val = XVECTOR (coding_spec)->contents[4];
- if (CONSP (val)
- && VECTORP (XCONS (val)->car)
- && VECTORP (XCONS (val)->cdr))
+ val = XVECTOR (coding_spec)->contents[4];
+ if (! CONSP (val)
+ || setup_ccl_program (&(coding->spec.ccl.decoder),
+ XCAR (val)) < 0
+ || setup_ccl_program (&(coding->spec.ccl.encoder),
+ XCDR (val)) < 0)
+ goto label_invalid_coding_system;
+
+ bzero (coding->spec.ccl.valid_codes, 256);
+ val = Fplist_get (plist, Qvalid_codes);
+ if (CONSP (val))
{
- setup_ccl_program (&(coding->spec.ccl.decoder), XCONS (val)->car);
- setup_ccl_program (&(coding->spec.ccl.encoder), XCONS (val)->cdr);
+ Lisp_Object this;
+
+ for (; CONSP (val); val = XCDR (val))
+ {
+ this = XCAR (val);
+ if (INTEGERP (this)
+ && XINT (this) >= 0 && XINT (this) < 256)
+ coding->spec.ccl.valid_codes[XINT (this)] = 1;
+ else if (CONSP (this)
+ && INTEGERP (XCAR (this))
+ && INTEGERP (XCDR (this)))
+ {
+ int start = XINT (XCAR (this));
+ int end = XINT (XCDR (this));
+
+ if (start >= 0 && start <= end && end < 256)
+ while (start <= end)
+ coding->spec.ccl.valid_codes[start++] = 1;
+ }
+ }
}
- else
- goto label_invalid_coding_system;
}
coding->common_flags |= CODING_REQUIRE_FLUSHING_MASK;
break;
return -1;
}
-/* Emacs has a mechanism to automatically detect a coding system if it
- is one of Emacs' internal format, ISO2022, SJIS, and BIG5. But,
- it's impossible to distinguish some coding systems accurately
- because they use the same range of codes. So, at first, coding
- systems are categorized into 7, those are:
-
- o coding-category-emacs-mule
+/* Setup raw-text or one of its subsidiaries in the structure
+ coding_system CODING according to the already setup value eol_type
+ in CODING. CODING should be setup for some coding system in
+ advance. */
- The category for a coding system which has the same code range
- as Emacs' internal format. Assigned the coding-system (Lisp
+void
+setup_raw_text_coding_system (coding)
+ struct coding_system *coding;
+{
+ if (coding->type != coding_type_raw_text)
+ {
+ coding->symbol = Qraw_text;
+ coding->type = coding_type_raw_text;
+ if (coding->eol_type != CODING_EOL_UNDECIDED)
+ {
+ Lisp_Object subsidiaries;
+ subsidiaries = Fget (Qraw_text, Qeol_type);
+
+ if (VECTORP (subsidiaries)
+ && XVECTOR (subsidiaries)->size == 3)
+ coding->symbol
+ = XVECTOR (subsidiaries)->contents[coding->eol_type];
+ }
+ setup_coding_system (coding->symbol, coding);
+ }
+ return;
+}
+
+/* Emacs has a mechanism to automatically detect a coding system if it
+ is one of Emacs' internal format, ISO2022, SJIS, and BIG5. But,
+ it's impossible to distinguish some coding systems accurately
+ because they use the same range of codes. So, at first, coding
+ systems are categorized into 7, those are:
+
+ o coding-category-emacs-mule
+
+ The category for a coding system which has the same code range
+ as Emacs' internal format. Assigned the coding-system (Lisp
symbol) `emacs-mule' by default.
o coding-category-sjis
as BIG5. Assigned the coding-system (Lisp symbol)
`cn-big5' by default.
+ o coding-category-ccl
+
+ The category for a coding system of which encoder/decoder is
+ written in CCL programs. The default value is nil, i.e., no
+ coding system is assigned.
+
o coding-category-binary
The category for a coding system not categorized in any of the
*/
+static
+int ascii_skip_code[256];
+
/* Detect how a text of length SRC_BYTES pointed by SOURCE is encoded.
If it detects possible coding systems, return an integer in which
appropriate flag bits are set. Flag bits are defined by macros
{
register unsigned char c;
unsigned char *src = source, *src_end = source + src_bytes;
- unsigned int mask = (CODING_CATEGORY_MASK_ISO_7BIT
- | CODING_CATEGORY_MASK_ISO_SHIFT);
+ unsigned int mask;
int i;
/* At first, skip all ASCII characters and control characters except
for three ISO2022 specific control characters. */
+ ascii_skip_code[ISO_CODE_SO] = 0;
+ ascii_skip_code[ISO_CODE_SI] = 0;
+ ascii_skip_code[ISO_CODE_ESC] = 0;
+
label_loop_detect_coding:
- while (src < src_end)
- {
- c = *src;
- if (c >= 0x80
- || ((mask & CODING_CATEGORY_MASK_ISO_7BIT)
- && c == ISO_CODE_ESC)
- || ((mask & CODING_CATEGORY_MASK_ISO_SHIFT)
- && (c == ISO_CODE_SI || c == ISO_CODE_SO)))
- break;
- src++;
- }
+ while (src < src_end && ascii_skip_code[*src]) src++;
*skip = src - source;
if (src >= src_end)
/* We found nothing other than ASCII. There's nothing to do. */
return 0;
+ c = *src;
/* The text seems to be encoded in some multilingual coding system.
Now, try to find in which coding system the text is encoded. */
if (c < 0x80)
{
/* No valid ISO2022 code follows C. Try again. */
src++;
- mask = (c != ISO_CODE_ESC
- ? CODING_CATEGORY_MASK_ISO_7BIT
- : CODING_CATEGORY_MASK_ISO_SHIFT);
+ if (c == ISO_CODE_ESC)
+ ascii_skip_code[ISO_CODE_ESC] = 1;
+ else
+ ascii_skip_code[ISO_CODE_SO] = ascii_skip_code[ISO_CODE_SI] = 1;
goto label_loop_detect_coding;
}
if (priorities)
| CODING_CATEGORY_MASK_SJIS
| CODING_CATEGORY_MASK_BIG5);
+ /* Or, we may have to consider the possibility of CCL. */
+ if (coding_system_table[CODING_CATEGORY_IDX_CCL]
+ && (coding_system_table[CODING_CATEGORY_IDX_CCL]
+ ->spec.ccl.valid_codes)[c])
+ try |= CODING_CATEGORY_MASK_CCL;
+
mask = 0;
if (priorities)
{
for (i = 0; i < CODING_CATEGORY_IDX_MAX; i++)
{
- priorities[i] &= try;
- if (priorities[i] & CODING_CATEGORY_MASK_ISO)
+ if (priorities[i] & try & CODING_CATEGORY_MASK_ISO)
mask = detect_coding_iso2022 (src, src_end);
- else if (priorities[i] & CODING_CATEGORY_MASK_SJIS)
+ else if (priorities[i] & try & CODING_CATEGORY_MASK_SJIS)
mask = detect_coding_sjis (src, src_end);
- else if (priorities[i] & CODING_CATEGORY_MASK_BIG5)
+ else if (priorities[i] & try & CODING_CATEGORY_MASK_BIG5)
mask = detect_coding_big5 (src, src_end);
- else if (priorities[i] & CODING_CATEGORY_MASK_EMACS_MULE)
+ else if (priorities[i] & try & CODING_CATEGORY_MASK_EMACS_MULE)
mask = detect_coding_emacs_mule (src, src_end);
+ else if (priorities[i] & try & CODING_CATEGORY_MASK_CCL)
+ mask = detect_coding_ccl (src, src_end);
+ else if (priorities[i] & CODING_CATEGORY_MASK_RAW_TEXT)
+ mask = CODING_CATEGORY_MASK_RAW_TEXT;
+ else if (priorities[i] & CODING_CATEGORY_MASK_BINARY)
+ mask = CODING_CATEGORY_MASK_BINARY;
if (mask)
goto label_return_highest_only;
}
if (try & CODING_CATEGORY_MASK_BIG5)
mask |= detect_coding_big5 (src, src_end);
if (try & CODING_CATEGORY_MASK_EMACS_MULE)
- mask |= detect_coding_emacs_mule (src, src_end);
+ mask |= detect_coding_emacs_mule (src, src_end);
+ if (try & CODING_CATEGORY_MASK_CCL)
+ mask |= detect_coding_ccl (src, src_end);
}
- return (mask | CODING_CATEGORY_MASK_RAW_TEXT);
+ return (mask | CODING_CATEGORY_MASK_RAW_TEXT | CODING_CATEGORY_MASK_BINARY);
label_return_highest_only:
for (i = 0; i < CODING_CATEGORY_IDX_MAX; i++)
{
unsigned int idx;
int skip, mask, i;
- int priorities[CODING_CATEGORY_IDX_MAX];
- Lisp_Object val = Vcoding_category_list;
-
- i = 0;
- while (CONSP (val) && i < CODING_CATEGORY_IDX_MAX)
- {
- if (! SYMBOLP (XCONS (val)->car))
- break;
- idx = XFASTINT (Fget (XCONS (val)->car, Qcoding_category_index));
- if (idx >= CODING_CATEGORY_IDX_MAX)
- break;
- priorities[i++] = (1 << idx);
- val = XCONS (val)->cdr;
- }
- /* If coding-category-list is valid and contains all coding
- categories, `i' should be CODING_CATEGORY_IDX_MAX now. If not,
- the following code saves Emacs from craching. */
- while (i < CODING_CATEGORY_IDX_MAX)
- priorities[i++] = CODING_CATEGORY_MASK_RAW_TEXT;
+ Lisp_Object val;
- mask = detect_coding_mask (src, src_bytes, priorities, &skip);
+ val = Vcoding_category_list;
+ mask = detect_coding_mask (src, src_bytes, coding_priorities, &skip);
coding->heading_ascii = skip;
if (!mask) return;
if (coding->eol_type != CODING_EOL_UNDECIDED)
{
- Lisp_Object tmp = Fget (val, Qeol_type);
+ Lisp_Object tmp;
+ tmp = Fget (val, Qeol_type);
if (VECTORP (tmp))
val = XVECTOR (tmp)->contents[coding->eol_type];
}
= encodep ? &coding->spec.ccl.encoder : &coding->spec.ccl.decoder;
int result;
+ ccl->last_block = coding->mode & CODING_MODE_LAST_BLOCK;
+
coding->produced = ccl_driver (ccl, source, destination,
src_bytes, dst_bytes, &(coding->consumed));
- if (encodep)
- {
- coding->produced_char = coding->produced;
- coding->consumed_char
- = multibyte_chars_in_text (source, coding->consumed);
- }
- else
- {
- coding->produced_char
- = multibyte_chars_in_text (destination, coding->produced);
- coding->consumed_char = coding->consumed;
- }
+ coding->produced_char
+ = (encodep
+ ? coding->produced
+ : multibyte_chars_in_text (destination, coding->produced));
+ coding->consumed_char
+ = multibyte_chars_in_text (source, coding->consumed);
+
switch (ccl->status)
{
case CCL_STAT_SUSPEND_BY_SRC:
case CCL_STAT_SUSPEND_BY_DST:
result = CODING_FINISH_INSUFFICIENT_DST;
break;
+ case CCL_STAT_QUIT:
+ case CCL_STAT_INVALID_CMD:
+ result = CODING_FINISH_INTERRUPT;
+ break;
default:
result = CODING_FINISH_NORMAL;
break;
/* See "GENERAL NOTES about `decode_coding_XXX ()' functions". Before
decoding, it may detect coding system and format of end-of-line if
- those are not yet decided. */
+ those are not yet decided.
+
+ This function does not make full use of DESTINATION buffer. For
+ instance, if coding->type is coding_type_iso2022, it uses only
+ (DST_BYTES - 7) bytes of DESTINATION buffer. In the case that
+ DST_BYTES is decided by the function decoding_buffer_size, it
+ contains extra 256 bytes (defined by CONVERSION_BUFFER_EXTRA_ROOM).
+ So, this function can decode the full SOURCE. But, in the other
+ case, if you want to avoid carry over, you must supply at least 7
+ bytes more area in DESTINATION buffer than expected maximum bytes
+ that will be produced by this function. */
int
decode_coding (coding, source, destination, src_bytes, dst_bytes)
{
int result;
- if (src_bytes <= 0)
+ if (src_bytes <= 0
+ && coding->type != coding_type_ccl
+ && ! (coding->mode & CODING_MODE_LAST_BLOCK
+ && CODING_REQUIRE_FLUSHING (coding)))
{
coding->produced = coding->produced_char = 0;
coding->consumed = coding->consumed_char = 0;
+ coding->fake_multibyte = 0;
return CODING_FINISH_NORMAL;
}
bcopy (source, destination, coding->produced);
else
safe_bcopy (source, destination, coding->produced);
+ coding->fake_multibyte = 1;
coding->consumed
= coding->consumed_char = coding->produced_char = coding->produced;
break;
return result;
}
-/* See "GENERAL NOTES about `encode_coding_XXX ()' functions". */
+/* See "GENERAL NOTES about `encode_coding_XXX ()' functions".
+
+ This function does not make full use of DESTINATION buffer. For
+ instance, if coding->type is coding_type_iso2022, it uses only
+ (DST_BYTES - 20) bytes of DESTINATION buffer. In the case that
+ DST_BYTES is decided by the function encoding_buffer_size, it
+ contains extra 256 bytes (defined by CONVERSION_BUFFER_EXTRA_ROOM).
+ So, this function can encode the full SOURCE. But, in the other
+ case, if you want to avoid carry over, you must supply at least 20
+ bytes more area in DESTINATION buffer than expected maximum bytes
+ that will be produced by this function. */
int
encode_coding (coding, source, destination, src_bytes, dst_bytes)
{
int result;
- if (src_bytes <= 0)
+ if (src_bytes <= 0
+ && ! (coding->mode & CODING_MODE_LAST_BLOCK
+ && CODING_REQUIRE_FLUSHING (coding)))
{
coding->produced = coding->produced_char = 0;
coding->consumed = coding->consumed_char = 0;
+ coding->fake_multibyte = 0;
return CODING_FINISH_NORMAL;
}
while (p < pend)
if (*p++ == '\015') p[-1] = '\n';
}
+ coding->fake_multibyte = 1;
coding->consumed
= coding->consumed_char = coding->produced_char = coding->produced;
break;
return result;
}
-/* Scan text in the region between *BEG and *END, skip characters
- which we don't have to decode by coding system CODING at the head
- and tail, then set *BEG and *END to the region of the text we
- actually have to convert.
+/* Scan text in the region between *BEG and *END (byte positions),
+ skip characters which we don't have to decode by coding system
+ CODING at the head and tail, then set *BEG and *END to the region
+ of the text we actually have to convert. The caller should move
+ the gap out of the region in advance.
If STR is not NULL, *BEG and *END are indices into STR. */
struct coding_system *coding;
unsigned char *str;
{
- unsigned char *begp_orig, *begp, *endp_orig, *endp;
+ unsigned char *begp_orig, *begp, *endp_orig, *endp, c;
int eol_conversion;
+ Lisp_Object translation_table;
if (coding->type == coding_type_ccl
|| coding->type == coding_type_undecided
}
else if (coding->type == coding_type_no_conversion)
{
- /* We need no conversion. */
- *beg = *end;
+ /* We need no conversion, but don't have to skip any data here.
+ Decoding routine handles them effectively anyway. */
return;
}
- if (coding->heading_ascii >= 0)
+ translation_table = coding->translation_table_for_decode;
+ if (NILP (translation_table) && !NILP (Venable_character_translation))
+ translation_table = Vstandard_translation_table_for_decode;
+ if (CHAR_TABLE_P (translation_table))
+ {
+ int i;
+ for (i = 0; i < 128; i++)
+ if (!NILP (CHAR_TABLE_REF (translation_table, i)))
+ break;
+ if (i < 128)
+ /* Some ASCII character should be tranlsated. We give up
+ shrinking. */
+ return;
+ }
+
+ eol_conversion = (coding->eol_type != CODING_EOL_LF);
+
+ if ((! eol_conversion) && (coding->heading_ascii >= 0))
/* Detection routine has already found how much we can skip at the
head. */
*beg += coding->heading_ascii;
}
else
{
- move_gap (*beg);
- begp_orig = begp = GAP_END_ADDR;
+ begp_orig = begp = BYTE_POS_ADDR (*beg);
endp_orig = endp = begp + *end - *beg;
}
- eol_conversion = (coding->eol_type != CODING_EOL_LF);
-
switch (coding->type)
{
case coding_type_emacs_mule:
if (eol_conversion)
{
if (coding->heading_ascii < 0)
- while (begp < endp && *begp != '\r') begp++;
- while (begp < endp && *(endp - 1) != '\r') endp--;
+ while (begp < endp && *begp != '\r' && *begp < 0x80) begp++;
+ while (begp < endp && endp[-1] != '\r' && endp[-1] < 0x80)
+ endp--;
+ /* Do not consider LF as ascii if preceded by CR, since that
+ confuses eol decoding. */
+ if (begp < endp && endp < endp_orig && endp[-1] == '\r' && endp[0] == '\n')
+ endp++;
}
else
begp = endp;
if (coding->heading_ascii < 0)
{
if (eol_conversion)
- while (begp < endp && *begp < 0x80 && *begp != '\n') begp++;
+ while (begp < endp && *begp < 0x80 && *begp != '\r') begp++;
else
while (begp < endp && *begp < 0x80) begp++;
}
/* We can skip all ASCII characters at the tail except for the
second byte of SJIS or BIG5 code. */
if (eol_conversion)
- while (begp < endp && endp[-1] < 0x80 && endp[-1] != '\n') endp--;
+ while (begp < endp && endp[-1] < 0x80 && endp[-1] != '\r') endp--;
else
while (begp < endp && endp[-1] < 0x80) endp--;
+ /* Do not consider LF as ascii if preceded by CR, since that
+ confuses eol decoding. */
+ if (begp < endp && endp < endp_orig && endp[-1] == '\r' && endp[0] == '\n')
+ endp++;
if (begp < endp && endp < endp_orig && endp[-1] >= 0x80)
endp++;
break;
default: /* i.e. case coding_type_iso2022: */
+ if (CODING_SPEC_ISO_INITIAL_DESIGNATION (coding, 0) != CHARSET_ASCII)
+ /* We can't skip any data. */
+ break;
if (coding->heading_ascii < 0)
{
- unsigned char c;
-
/* We can skip all ASCII characters at the head except for a
few control codes. */
while (begp < endp && (c = *begp) < 0x80
case CODING_CATEGORY_IDX_ISO_8_2:
/* We can skip all ASCII characters at the tail. */
if (eol_conversion)
- while (begp < endp && endp[-1] < 0x80 && endp[-1] != '\n') endp--;
+ while (begp < endp && (c = endp[-1]) < 0x80 && c != '\r') endp--;
else
while (begp < endp && endp[-1] < 0x80) endp--;
+ /* Do not consider LF as ascii if preceded by CR, since that
+ confuses eol decoding. */
+ if (begp < endp && endp < endp_orig && endp[-1] == '\r' && endp[0] == '\n')
+ endp++;
break;
case CODING_CATEGORY_IDX_ISO_7:
case CODING_CATEGORY_IDX_ISO_7_TIGHT:
- /* We can skip all charactes at the tail except for ESC and
- the following 2-byte at the tail. */
- if (eol_conversion)
- while (begp < endp && endp[-1] != ISO_CODE_ESC && endp[-1] != '\n')
- endp--;
- else
- while (begp < endp && endp[-1] != ISO_CODE_ESC)
- endp--;
- if (begp < endp && endp[-1] == ISO_CODE_ESC)
- {
- if (endp + 1 < endp_orig && end[0] == '(' && end[1] == 'B')
- /* This is an ASCII designation sequence. We can
- surely skip the tail. */
- endp += 2;
- else
- /* Hmmm, we can't skip the tail. */
- endp = endp_orig;
- }
+ {
+ /* We can skip all charactes at the tail except for 8-bit
+ codes and ESC and the following 2-byte at the tail. */
+ unsigned char *eight_bit = NULL;
+
+ if (eol_conversion)
+ while (begp < endp
+ && (c = endp[-1]) != ISO_CODE_ESC && c != '\r')
+ {
+ if (!eight_bit && c & 0x80) eight_bit = endp;
+ endp--;
+ }
+ else
+ while (begp < endp
+ && (c = endp[-1]) != ISO_CODE_ESC)
+ {
+ if (!eight_bit && c & 0x80) eight_bit = endp;
+ endp--;
+ }
+ /* Do not consider LF as ascii if preceded by CR, since that
+ confuses eol decoding. */
+ if (begp < endp && endp < endp_orig
+ && endp[-1] == '\r' && endp[0] == '\n')
+ endp++;
+ if (begp < endp && endp[-1] == ISO_CODE_ESC)
+ {
+ if (endp + 1 < endp_orig && end[0] == '(' && end[1] == 'B')
+ /* This is an ASCII designation sequence. We can
+ surely skip the tail. But, if we have
+ encountered an 8-bit code, skip only the codes
+ after that. */
+ endp = eight_bit ? eight_bit : endp + 2;
+ else
+ /* Hmmm, we can't skip the tail. */
+ endp = endp_orig;
+ }
+ else if (eight_bit)
+ endp = eight_bit;
+ }
}
}
*beg += begp - begp_orig;
{
unsigned char *begp_orig, *begp, *endp_orig, *endp;
int eol_conversion;
+ Lisp_Object translation_table;
if (coding->type == coding_type_ccl)
/* We can't skip any data. */
return;
}
+ translation_table = coding->translation_table_for_encode;
+ if (NILP (translation_table) && !NILP (Venable_character_translation))
+ translation_table = Vstandard_translation_table_for_encode;
+ if (CHAR_TABLE_P (translation_table))
+ {
+ int i;
+ for (i = 0; i < 128; i++)
+ if (!NILP (CHAR_TABLE_REF (translation_table, i)))
+ break;
+ if (i < 128)
+ /* Some ASCII character should be tranlsated. We give up
+ shrinking. */
+ return;
+ }
+
if (str)
{
begp_orig = begp = str + *beg;
}
else
{
- move_gap (*beg);
- begp_orig = begp = GAP_END_ADDR;
+ begp_orig = begp = BYTE_POS_ADDR (*beg);
endp_orig = endp = begp + *end - *beg;
}
break;
case coding_type_iso2022:
+ if (CODING_SPEC_ISO_INITIAL_DESIGNATION (coding, 0) != CHARSET_ASCII)
+ /* We can't skip any data. */
+ break;
if (coding->flags & CODING_FLAG_ISO_DESIGNATE_AT_BOL)
{
unsigned char *bol = begp;
return;
}
+/* As shrinking conversion region requires some overhead, we don't try
+ shrinking if the length of conversion region is less than this
+ value. */
+static int shrink_conversion_region_threshhold = 1024;
+
+#define SHRINK_CONVERSION_REGION(beg, end, coding, str, encodep) \
+ do { \
+ if (*(end) - *(beg) > shrink_conversion_region_threshhold) \
+ { \
+ if (encodep) shrink_encoding_region (beg, end, coding, str); \
+ else shrink_decoding_region (beg, end, coding, str); \
+ } \
+ } while (0)
+
/* Decode (if ENCODEP is zero) or encode (if ENCODEP is nonzero) the
- text from FROM to TO by coding system CODING, and return number of
- characters in the resulting text.
+ text from FROM to TO (byte positions are FROM_BYTE and TO_BYTE) by
+ coding system CODING, and return the status code of code conversion
+ (currently, this value has no meaning).
- If ADJUST is nonzero, we do various things as if the original text
- is deleted and a new text is inserted. See the comments in
- replace_range (insdel.c) to know what we are doing.
+ How many characters (and bytes) are converted to how many
+ characters (and bytes) are recorded in members of the structure
+ CODING.
- ADJUST nonzero also means that post-read-conversion or
- pre-write-conversion functions (if any) should be processed. */
+ If REPLACE is nonzero, we do various things as if the original text
+ is deleted and a new text is inserted. See the comments in
+ replace_range (insdel.c) to know what we are doing. */
int
-code_convert_region (from, to, coding, encodep, adjust)
- int from, to, encodep, adjust;
+code_convert_region (from, from_byte, to, to_byte, coding, encodep, replace)
+ int from, from_byte, to, to_byte, encodep, replace;
struct coding_system *coding;
{
- int len = to - from, require, inserted, inserted_byte;
- int from_byte, to_byte, len_byte;
- int from_byte_orig, to_byte_orig;
- Lisp_Object saved_coding_symbol = Qnil;
+ int len = to - from, len_byte = to_byte - from_byte;
+ int require, inserted, inserted_byte;
+ int head_skip, tail_skip, total_skip;
+ Lisp_Object saved_coding_symbol;
+ int multibyte = !NILP (current_buffer->enable_multibyte_characters);
+ int first = 1;
+ int fake_multibyte = 0;
+ unsigned char *src, *dst;
+ Lisp_Object deletion;
+ int orig_point = PT, orig_len = len;
+ int prev_Z;
+
+ deletion = Qnil;
+ saved_coding_symbol = Qnil;
+
+ if (from < PT && PT < to)
+ {
+ TEMP_SET_PT_BOTH (from, from_byte);
+ orig_point = from;
+ }
- if (adjust)
+ if (replace)
{
+ int saved_from = from;
+
prepare_to_modify_buffer (from, to, &from);
- to = from + len;
+ if (saved_from != from)
+ {
+ to = from + len;
+ if (multibyte)
+ from_byte = CHAR_TO_BYTE (from), to_byte = CHAR_TO_BYTE (to);
+ else
+ from_byte = from, to_byte = to;
+ len_byte = to_byte - from_byte;
+ }
}
- from_byte = CHAR_TO_BYTE (from); to_byte = CHAR_TO_BYTE (to);
- len_byte = from_byte - to_byte;
if (! encodep && CODING_REQUIRE_DETECTION (coding))
{
- /* We must detect encoding of text and eol. Even if detection
- routines can't decide the encoding, we should not let them
- undecided because the deeper decoding routine (decode_coding)
- tries to detect the encodings in vain in that case. */
+ /* We must detect encoding of text and eol format. */
if (from < GPT && to > GPT)
move_gap_both (from, from_byte);
if (coding->type == coding_type_undecided)
{
- detect_coding (coding, BYTE_POS_ADDR (from), len);
+ detect_coding (coding, BYTE_POS_ADDR (from_byte), len_byte);
if (coding->type == coding_type_undecided)
+ /* It seems that the text contains only ASCII, but we
+ should not left it undecided because the deeper
+ decoding routine (decode_coding) tries to detect the
+ encodings again in vain. */
coding->type = coding_type_emacs_mule;
}
if (coding->eol_type == CODING_EOL_UNDECIDED)
}
}
+ coding->consumed_char = len, coding->consumed = len_byte;
+
if (encodep
? ! CODING_REQUIRE_ENCODING (coding)
: ! CODING_REQUIRE_DECODING (coding))
- return len;
+ {
+ coding->produced = len_byte;
+ if (multibyte
+ && ! replace
+ /* See the comment of the member heading_ascii in coding.h. */
+ && coding->heading_ascii < len_byte)
+ {
+ /* We still may have to combine byte at the head and the
+ tail of the text in the region. */
+ if (from < GPT && GPT < to)
+ move_gap_both (to, to_byte);
+ len = multibyte_chars_in_text (BYTE_POS_ADDR (from_byte), len_byte);
+ adjust_after_insert (from, from_byte, to, to_byte, len);
+ coding->produced_char = len;
+ }
+ else
+ {
+ if (!replace)
+ adjust_after_insert (from, from_byte, to, to_byte, len_byte);
+ coding->produced_char = len_byte;
+ }
+ return 0;
+ }
/* Now we convert the text. */
/* For encoding, we must process pre-write-conversion in advance. */
if (encodep
- && adjust
&& ! NILP (coding->pre_write_conversion)
&& SYMBOLP (coding->pre_write_conversion)
&& ! NILP (Ffboundp (coding->pre_write_conversion)))
{
- /* The function in pre-write-conversion put a new text in a new
- buffer. */
- struct buffer *prev = current_buffer, *new;
+ /* The function in pre-write-conversion may put a new text in a
+ new buffer. */
+ struct buffer *prev = current_buffer;
+ Lisp_Object new;
- call2 (coding->pre_write_conversion, from, to);
+ call2 (coding->pre_write_conversion,
+ make_number (from), make_number (to));
if (current_buffer != prev)
{
len = ZV - BEGV;
- new = current_buffer;
+ new = Fcurrent_buffer ();
set_buffer_internal_1 (prev);
- del_range (from, to);
- insert_from_buffer (new, BEG, len, 0);
+ del_range_2 (from, from_byte, to, to_byte);
+ TEMP_SET_PT_BOTH (from, from_byte);
+ insert_from_buffer (XBUFFER (new), 1, len, 0);
+ Fkill_buffer (new);
+ if (orig_point >= to)
+ orig_point += len - orig_len;
+ else if (orig_point > from)
+ orig_point = from;
+ orig_len = len;
to = from + len;
- to_byte = CHAR_TO_BYTE (to);
+ from_byte = multibyte ? CHAR_TO_BYTE (from) : from_byte;
+ to_byte = multibyte ? CHAR_TO_BYTE (to) : to;
len_byte = to_byte - from_byte;
+ TEMP_SET_PT_BOTH (from, from_byte);
}
}
+ if (replace)
+ deletion = make_buffer_string_both (from, from_byte, to, to_byte, 1);
+
/* Try to skip the heading and tailing ASCIIs. */
- from_byte_orig = from_byte; to_byte_orig = to_byte;
- if (encodep)
- shrink_encoding_region (&from_byte, &to_byte, coding, NULL);
- else
- shrink_decoding_region (&from_byte, &to_byte, coding, NULL);
- if (from_byte == to_byte)
- return len;
- /* Here, the excluded region by shrinking contains only ASCIIs. */
- from += (from_byte - from_byte_orig);
- to += (to_byte - to_byte_orig);
- len = to - from;
- len_byte = to_byte - from_byte;
-
- /* For converion, we must put the gap before the text to be decoded
- in addition to make the gap larger for efficient decoding. The
- required gap size starts from 2000 which is the magic number used
- in make_gap. But, after one batch of conversion, it will be
- incremented if we find that it is not enough . */
+ {
+ int from_byte_orig = from_byte, to_byte_orig = to_byte;
+
+ if (from < GPT && GPT < to)
+ move_gap_both (from, from_byte);
+ SHRINK_CONVERSION_REGION (&from_byte, &to_byte, coding, NULL, encodep);
+ if (from_byte == to_byte
+ && coding->type != coding_type_ccl
+ && ! (coding->mode & CODING_MODE_LAST_BLOCK
+ && CODING_REQUIRE_FLUSHING (coding)))
+ {
+ coding->produced = len_byte;
+ coding->produced_char = multibyte ? len : len_byte;
+ if (!replace)
+ /* We must record and adjust for this new text now. */
+ adjust_after_insert (from, from_byte_orig, to, to_byte_orig, len);
+ return 0;
+ }
+
+ head_skip = from_byte - from_byte_orig;
+ tail_skip = to_byte_orig - to_byte;
+ total_skip = head_skip + tail_skip;
+ from += head_skip;
+ to -= tail_skip;
+ len -= total_skip; len_byte -= total_skip;
+ }
+
+ /* The code conversion routine can not preserve text properties for
+ now. So, we must remove all text properties in the region.
+ Here, we must suppress all modification hooks. */
+ if (replace)
+ {
+ int saved_inhibit_modification_hooks = inhibit_modification_hooks;
+ inhibit_modification_hooks = 1;
+ Fset_text_properties (make_number (from), make_number (to), Qnil, Qnil);
+ inhibit_modification_hooks = saved_inhibit_modification_hooks;
+ }
+
+ /* For converion, we must put the gap before the text in addition to
+ making the gap larger for efficient decoding. The required gap
+ size starts from 2000 which is the magic number used in make_gap.
+ But, after one batch of conversion, it will be incremented if we
+ find that it is not enough . */
require = 2000;
if (GAP_SIZE < require)
make_gap (require - GAP_SIZE);
move_gap_both (from, from_byte);
- if (adjust)
- adjust_before_replace (from, from_byte, to, to_byte);
+ inserted = inserted_byte = 0;
+ src = GAP_END_ADDR, dst = GPT_ADDR;
- if (GPT - BEG < beg_unchanged)
- beg_unchanged = GPT - BEG;
- if (Z - GPT < end_unchanged)
- end_unchanged = Z - GPT;
+ GAP_SIZE += len_byte;
+ ZV -= len;
+ Z -= len;
+ ZV_BYTE -= len_byte;
+ Z_BYTE -= len_byte;
+
+ if (GPT - BEG < BEG_UNCHANGED)
+ BEG_UNCHANGED = GPT - BEG;
+ if (Z - GPT < END_UNCHANGED)
+ END_UNCHANGED = Z - GPT;
- inserted = inserted_byte = 0;
for (;;)
{
- int result, diff_char, diff_byte;
+ int result;
/* The buffer memory is changed from:
- +--------+converted-text+------------+-----original-text-----+---+
- |<-from->|<--inserted-->|<-GAP_SIZE->|<---------len--------->|---| */
-
+ +--------+converted-text+---------+-------original-text------+---+
+ |<-from->|<--inserted-->|---------|<-----------len---------->|---|
+ |<------------------- GAP_SIZE -------------------->| */
if (encodep)
- result = encode_coding (coding, GAP_END_ADDR, GPT_ADDR, len_byte, 0);
+ result = encode_coding (coding, src, dst, len_byte, 0);
else
- result = decode_coding (coding, GAP_END_ADDR, GPT_ADDR, len_byte, 0);
+ result = decode_coding (coding, src, dst, len_byte, 0);
/* to:
+--------+-------converted-text--------+--+---original-text--+---+
- |<-from->|<----(inserted+produced)---->|--|<-(len-consumed)->|---| */
-
- diff_char = coding->produced_char - coding->consumed_char;
- diff_byte = coding->produced - coding->consumed;
-
- GAP_SIZE -= diff_byte;
- ZV += diff_char; ZV_BYTE += diff_byte;
- Z += diff_char; Z_BYTE += diff_byte;
- GPT += coding->produced_char; GPT_BYTE += coding->produced;
+ |<-from->|<--inserted-->|<--produced-->|--|<-(len-consumed)->|---|
+ |<------------------- GAP_SIZE -------------------->| */
+ if (coding->fake_multibyte)
+ fake_multibyte = 1;
+ if (!encodep && !multibyte)
+ coding->produced_char = coding->produced;
inserted += coding->produced_char;
inserted_byte += coding->produced;
- len -= coding->consumed_char;
len_byte -= coding->consumed;
+ src += coding->consumed;
+ dst += inserted_byte;
+ if (result == CODING_FINISH_NORMAL)
+ {
+ src += len_byte;
+ break;
+ }
if (! encodep && result == CODING_FINISH_INCONSISTENT_EOL)
{
- unsigned char *p = GPT_ADDR - inserted_byte, *pend = GPT_ADDR;
+ unsigned char *pend = dst, *p = pend - inserted_byte;
+ Lisp_Object eol_type;
/* Encode LFs back to the original eol format (CR or CRLF). */
if (coding->eol_type == CODING_EOL_CR)
}
else
{
- unsigned char *p2 = p;
int count = 0;
- while (p2 < pend) if (*p2++ == '\n') count++;
- if (GAP_SIZE < count)
- make_gap (count - GAP_SIZE);
- p2 = GPT_ADDR + count;
- while (p < pend)
+ while (p < pend) if (*p++ == '\n') count++;
+ if (src - dst < count)
{
- *--p2 = *--pend;
- if (*pend == '\n') *--p2 = '\r';
+ /* We don't have sufficient room for encoding LFs
+ back to CRLF. We must record converted and
+ not-yet-converted text back to the buffer
+ content, enlarge the gap, then record them out of
+ the buffer contents again. */
+ int add = len_byte + inserted_byte;
+
+ GAP_SIZE -= add;
+ ZV += add; Z += add; ZV_BYTE += add; Z_BYTE += add;
+ GPT += inserted_byte; GPT_BYTE += inserted_byte;
+ make_gap (count - GAP_SIZE);
+ GAP_SIZE += add;
+ ZV -= add; Z -= add; ZV_BYTE -= add; Z_BYTE -= add;
+ GPT -= inserted_byte; GPT_BYTE -= inserted_byte;
+ /* Don't forget to update SRC, DST, and PEND. */
+ src = GAP_END_ADDR - len_byte;
+ dst = GPT_ADDR + inserted_byte;
+ pend = dst;
}
- GPT += count; GAP_SIZE -= count; ZV += count; Z += count;
- ZV_BYTE += count; Z_BYTE += count;
- coding->produced += count;
- coding->produced_char += count;
inserted += count;
inserted_byte += count;
+ coding->produced += count;
+ p = dst = pend + count;
+ while (count)
+ {
+ *--p = *--pend;
+ if (*p == '\n') count--, *--p = '\r';
+ }
}
/* Suppress eol-format conversion in the further conversion. */
coding->eol_type = CODING_EOL_LF;
- /* Restore the original symbol. */
- coding->symbol = saved_coding_symbol;
+ /* Set the coding system symbol to that for Unix-like EOL. */
+ eol_type = Fget (saved_coding_symbol, Qeol_type);
+ if (VECTORP (eol_type)
+ && XVECTOR (eol_type)->size == 3
+ && SYMBOLP (XVECTOR (eol_type)->contents[CODING_EOL_LF]))
+ coding->symbol = XVECTOR (eol_type)->contents[CODING_EOL_LF];
+ else
+ coding->symbol = saved_coding_symbol;
+
+ continue;
}
if (len_byte <= 0)
- break;
+ {
+ if (coding->type != coding_type_ccl
+ || coding->mode & CODING_MODE_LAST_BLOCK)
+ break;
+ coding->mode |= CODING_MODE_LAST_BLOCK;
+ continue;
+ }
if (result == CODING_FINISH_INSUFFICIENT_SRC)
{
/* The source text ends in invalid codes. Let's just
make them valid buffer contents, and finish conversion. */
- inserted += len;
+ inserted += len_byte;
inserted_byte += len_byte;
+ while (len_byte--)
+ *dst++ = *src++;
+ fake_multibyte = 1;
+ break;
+ }
+ if (result == CODING_FINISH_INTERRUPT)
+ {
+ /* The conversion procedure was interrupted by a user. */
+ fake_multibyte = 1;
break;
}
- if (inserted == coding->produced_char)
- /* We have just done the first batch of conversion. Let's
- reconsider the required gap size now.
-
- We have converted CONSUMED bytes into PRODUCED bytes. To
- convert the remaining LEN bytes, we may need REQUIRE bytes
- of gap, where:
- REQUIRE + LEN = (LEN * PRODUCED / CONSUMED)
- REQUIRE = LEN * (PRODUCED - CONSUMED) / CONSUMED
- = LEN * DIFF / CONSUMED
- Here, we are sure that DIFF is positive. */
- require = len_byte * diff_byte / coding->consumed;
- if (GAP_SIZE < require)
- make_gap (require - GAP_SIZE);
+ /* Now RESULT == CODING_FINISH_INSUFFICIENT_DST */
+ if (coding->consumed < 1)
+ {
+ /* It's quite strange to require more memory without
+ consuming any bytes. Perhaps CCL program bug. */
+ fake_multibyte = 1;
+ break;
+ }
+ if (first)
+ {
+ /* We have just done the first batch of conversion which was
+ stoped because of insufficient gap. Let's reconsider the
+ required gap size (i.e. SRT - DST) now.
+
+ We have converted ORIG bytes (== coding->consumed) into
+ NEW bytes (coding->produced). To convert the remaining
+ LEN bytes, we may need REQUIRE bytes of gap, where:
+ REQUIRE + LEN_BYTE = LEN_BYTE * (NEW / ORIG)
+ REQUIRE = LEN_BYTE * (NEW - ORIG) / ORIG
+ Here, we are sure that NEW >= ORIG. */
+ float ratio = coding->produced - coding->consumed;
+ ratio /= coding->consumed;
+ require = len_byte * ratio;
+ first = 0;
+ }
+ if ((src - dst) < (require + 2000))
+ {
+ /* See the comment above the previous call of make_gap. */
+ int add = len_byte + inserted_byte;
+
+ GAP_SIZE -= add;
+ ZV += add; Z += add; ZV_BYTE += add; Z_BYTE += add;
+ GPT += inserted_byte; GPT_BYTE += inserted_byte;
+ make_gap (require + 2000);
+ GAP_SIZE += add;
+ ZV -= add; Z -= add; ZV_BYTE -= add; Z_BYTE -= add;
+ GPT -= inserted_byte; GPT_BYTE -= inserted_byte;
+ /* Don't forget to update SRC, DST. */
+ src = GAP_END_ADDR - len_byte;
+ dst = GPT_ADDR + inserted_byte;
+ }
}
- if (GAP_SIZE > 0) *GPT_ADDR = 0; /* Put an anchor. */
+ if (src - dst > 0) *dst = 0; /* Put an anchor. */
+
+ if (multibyte
+ && (encodep
+ || fake_multibyte
+ || (to - from) != (to_byte - from_byte)))
+ inserted = multibyte_chars_in_text (GPT_ADDR, inserted_byte);
- if (adjust)
+ /* If we have shrinked the conversion area, adjust it now. */
+ if (total_skip > 0)
{
- adjust_after_replace (from, from_byte, to, to_byte,
- inserted, inserted_byte);
+ if (tail_skip > 0)
+ safe_bcopy (GAP_END_ADDR, GPT_ADDR + inserted_byte, tail_skip);
+ inserted += total_skip; inserted_byte += total_skip;
+ GAP_SIZE += total_skip;
+ GPT -= head_skip; GPT_BYTE -= head_skip;
+ ZV -= total_skip; ZV_BYTE -= total_skip;
+ Z -= total_skip; Z_BYTE -= total_skip;
+ from -= head_skip; from_byte -= head_skip;
+ to += tail_skip; to_byte += tail_skip;
+ }
- if (! encodep && ! NILP (coding->post_read_conversion))
- {
- Lisp_Object val;
- int orig_inserted = inserted, pos = PT;
+ prev_Z = Z;
+ adjust_after_replace (from, from_byte, deletion, inserted, inserted_byte);
+ inserted = Z - prev_Z;
- temp_set_point_both (current_buffer, from, from_byte);
- val = call1 (coding->post_read_conversion, make_number (inserted));
- if (! NILP (val))
- {
- CHECK_NUMBER (val, 0);
- inserted = XFASTINT (val);
- }
- if (pos >= from + orig_inserted)
- temp_set_point (current_buffer, pos + (inserted - orig_inserted));
- }
+ if (! encodep && ! NILP (coding->post_read_conversion))
+ {
+ Lisp_Object val;
+
+ if (from != PT)
+ TEMP_SET_PT_BOTH (from, from_byte);
+ prev_Z = Z;
+ val = call1 (coding->post_read_conversion, make_number (inserted));
+ CHECK_NUMBER (val, 0);
+ inserted += Z - prev_Z;
}
- return ((from_byte - from_byte_orig) + inserted + (to_byte_orig - to_byte));
+ if (orig_point >= from)
+ {
+ if (orig_point >= from + orig_len)
+ orig_point += inserted - orig_len;
+ else
+ orig_point = from;
+ TEMP_SET_PT (orig_point);
+ }
+
+ signal_after_change (from, to - from, inserted);
+
+ {
+ coding->consumed = to_byte - from_byte;
+ coding->consumed_char = to - from;
+ coding->produced = inserted_byte;
+ coding->produced_char = inserted;
+ }
+
+ return 0;
}
Lisp_Object
{
int len;
char *buf;
- int from = 0, to = XSTRING (str)->size, to_byte = XSTRING (str)->size_byte;
+ int from = 0, to = XSTRING (str)->size;
+ int to_byte = STRING_BYTES (XSTRING (str));
struct gcpro gcpro1;
- Lisp_Object saved_coding_symbol = Qnil;
+ Lisp_Object saved_coding_symbol;
int result;
+ saved_coding_symbol = Qnil;
if (encodep && !NILP (coding->pre_write_conversion)
|| !encodep && !NILP (coding->post_read_conversion))
{
code_convert_region. */
int count = specpdl_ptr - specpdl;
struct buffer *prev = current_buffer;
-
+
record_unwind_protect (Fset_buffer, Fcurrent_buffer ());
temp_output_buffer_setup (" *code-converting-work*");
set_buffer_internal (XBUFFER (Vstandard_output));
insert_from_string (str, 0, 0, to_byte, to_byte, 0);
current_buffer->enable_multibyte_characters = Qt;
}
- code_convert_region (BEGV, ZV, coding, encodep, 1);
+ code_convert_region (BEGV, BEGV_BYTE, ZV, ZV_BYTE, coding, encodep, 1);
if (encodep)
/* We must return the buffer contents as unibyte string. */
current_buffer->enable_multibyte_characters = Qnil;
else
{
/* Try to skip the heading and tailing ASCIIs. */
- if (encodep)
- shrink_encoding_region (&from, &to_byte, coding, XSTRING (str)->data);
- else
- shrink_decoding_region (&from, &to_byte, coding, XSTRING (str)->data);
+ SHRINK_CONVERSION_REGION (&from, &to_byte, coding, XSTRING (str)->data,
+ encodep);
}
- if (from == to_byte)
+ if (from == to_byte
+ && coding->type != coding_type_ccl)
return (nocopy ? str : Fcopy_sequence (str));
if (encodep)
len = encoding_buffer_size (coding, to_byte - from);
else
len = decoding_buffer_size (coding, to_byte - from);
- len += from + XSTRING (str)->size_byte - to_byte;
+ len += from + STRING_BYTES (XSTRING (str)) - to_byte;
GCPRO1 (str);
buf = get_conversion_buffer (len);
UNGCPRO;
? encode_coding (coding, XSTRING (str)->data + from,
buf + from, to_byte - from, len)
: decode_coding (coding, XSTRING (str)->data + from,
- buf + from, to - from, len));
+ buf + from, to_byte - from, len));
if (! encodep && result == CODING_FINISH_INCONSISTENT_EOL)
{
/* We simple try to decode the whole string again but without
}
bcopy (XSTRING (str)->data + to_byte, buf + from + coding->produced,
- XSTRING (str)->size_byte - to_byte);
+ STRING_BYTES (XSTRING (str)) - to_byte);
- len = from + XSTRING (str)->size_byte - to_byte;
+ len = from + STRING_BYTES (XSTRING (str)) - to_byte;
if (encodep)
str = make_unibyte_string (buf, len + coding->produced);
else
- str = make_multibyte_string (buf, len + coding->produced_char,
- len + coding->produced);
+ {
+ int chars= (coding->fake_multibyte
+ ? multibyte_chars_in_text (buf + from, coding->produced)
+ : coding->produced_char);
+ str = make_multibyte_string (buf, len + chars, len + coding->produced);
+ }
+
return str;
}
\f
#ifdef emacs
-/*** 7. Emacs Lisp library functions ***/
+/*** 8. Emacs Lisp library functions ***/
DEFUN ("coding-system-p", Fcoding_system_p, Scoding_system_p, 1, 1, 0,
"Return t if OBJECT is nil or a coding-system.\n\
coding_mask = detect_coding_mask (src, src_bytes, NULL, &dummy);
eol_type = detect_eol_type (src, src_bytes, &dummy);
if (eol_type == CODING_EOL_INCONSISTENT)
- eol_type == CODING_EOL_UNDECIDED;
+ eol_type = CODING_EOL_UNDECIDED;
if (!coding_mask)
{
if (VECTORP (val2))
val = XVECTOR (val2)->contents[eol_type];
}
- return val;
+ return (highest ? val : Fcons (val, Qnil));
}
/* At first, gather possible coding systems in VAL. */
val = Qnil;
- for (tmp = Vcoding_category_list; !NILP (tmp); tmp = XCONS (tmp)->cdr)
+ for (tmp = Vcoding_category_list; !NILP (tmp); tmp = XCDR (tmp))
{
int idx
- = XFASTINT (Fget (XCONS (tmp)->car, Qcoding_category_index));
+ = XFASTINT (Fget (XCAR (tmp), Qcoding_category_index));
if (coding_mask & (1 << idx))
{
- val = Fcons (Fsymbol_value (XCONS (tmp)->car), val);
+ val = Fcons (Fsymbol_value (XCAR (tmp)), val);
if (highest)
break;
}
if (!highest)
val = Fnreverse (val);
- /* Then, substitute the elements by subsidiary coding systems. */
- for (tmp = val; !NILP (tmp); tmp = XCONS (tmp)->cdr)
+ /* Then, replace the elements with subsidiary coding systems. */
+ for (tmp = val; !NILP (tmp); tmp = XCDR (tmp))
{
- if (eol_type != CODING_EOL_UNDECIDED)
+ if (eol_type != CODING_EOL_UNDECIDED
+ && eol_type != CODING_EOL_INCONSISTENT)
{
Lisp_Object eol;
- eol = Fget (XCONS (tmp)->car, Qeol_type);
+ eol = Fget (XCAR (tmp), Qeol_type);
if (VECTORP (eol))
- XCONS (tmp)->car = XVECTOR (eol)->contents[eol_type];
+ XCAR (tmp) = XVECTOR (eol)->contents[eol_type];
}
}
- return (highest ? XCONS (val)->car : val);
+ return (highest ? XCAR (val) : val);
}
DEFUN ("detect-coding-region", Fdetect_coding_region, Sdetect_coding_region,
"Detect coding system of the text in the region between START and END.\n\
Return a list of possible coding systems ordered by priority.\n\
\n\
-If only ASCII characters are found, it returns `undecided'\n\
-or its subsidiary coding system according to a detected end-of-line format.\n\
+If only ASCII characters are found, it returns a list of single element\n\
+`undecided' or its subsidiary coding system according to a detected\n\
+end-of-line format.\n\
\n\
If optional argument HIGHEST is non-nil, return the coding system of\n\
highest priority.")
"Detect coding system of the text in STRING.\n\
Return a list of possible coding systems ordered by priority.\n\
\n\
-If only ASCII characters are found, it returns `undecided'\n\
-or its subsidiary coding system according to a detected end-of-line format.\n\
+If only ASCII characters are found, it returns a list of single element\n\
+`undecided' or its subsidiary coding system according to a detected\n\
+end-of-line format.\n\
\n\
If optional argument HIGHEST is non-nil, return the coding system of\n\
highest priority.")
CHECK_STRING (string, 0);
return detect_coding_system (XSTRING (string)->data,
- XSTRING (string)->size_byte,
+ STRING_BYTES (XSTRING (string)),
!NILP (highest));
}
-DEFUN ("decode-coding-region", Fdecode_coding_region, Sdecode_coding_region,
- 3, 3, "r\nzCoding system: ",
- "Decode the current region by specified coding system.\n\
-When called from a program, takes three arguments:\n\
-START, END, and CODING-SYSTEM. START and END are buffer positions.\n\
-Return length of decoded text.")
- (start, end, coding_system)
+Lisp_Object
+code_convert_region1 (start, end, coding_system, encodep)
Lisp_Object start, end, coding_system;
+ int encodep;
{
struct coding_system coding;
- int from, to;
+ int from, to, len;
CHECK_NUMBER_COERCE_MARKER (start, 0);
CHECK_NUMBER_COERCE_MARKER (end, 1);
error ("Invalid coding system: %s", XSYMBOL (coding_system)->name->data);
coding.mode |= CODING_MODE_LAST_BLOCK;
- return code_convert_region (from, to, &coding, 0, 1);
+ code_convert_region (from, CHAR_TO_BYTE (from), to, CHAR_TO_BYTE (to),
+ &coding, encodep, 1);
+ Vlast_coding_system_used = coding.symbol;
+ return make_number (coding.produced_char);
+}
+
+DEFUN ("decode-coding-region", Fdecode_coding_region, Sdecode_coding_region,
+ 3, 3, "r\nzCoding system: ",
+ "Decode the current region by specified coding system.\n\
+When called from a program, takes three arguments:\n\
+START, END, and CODING-SYSTEM. START and END are buffer positions.\n\
+This function sets `last-coding-system-used' to the precise coding system\n\
+used (which may be different from CODING-SYSTEM if CODING-SYSTEM is\n\
+not fully specified.)\n\
+It returns the length of the decoded text.")
+ (start, end, coding_system)
+ Lisp_Object start, end, coding_system;
+{
+ return code_convert_region1 (start, end, coding_system, 0);
}
DEFUN ("encode-coding-region", Fencode_coding_region, Sencode_coding_region,
"Encode the current region by specified coding system.\n\
When called from a program, takes three arguments:\n\
START, END, and CODING-SYSTEM. START and END are buffer positions.\n\
-Return length of encoded text.")
+This function sets `last-coding-system-used' to the precise coding system\n\
+used (which may be different from CODING-SYSTEM if CODING-SYSTEM is\n\
+not fully specified.)\n\
+It returns the length of the encoded text.")
(start, end, coding_system)
Lisp_Object start, end, coding_system;
{
- struct coding_system coding;
- int from, to;
+ return code_convert_region1 (start, end, coding_system, 1);
+}
- CHECK_NUMBER_COERCE_MARKER (start, 0);
- CHECK_NUMBER_COERCE_MARKER (end, 1);
- CHECK_SYMBOL (coding_system, 2);
+Lisp_Object
+code_convert_string1 (string, coding_system, nocopy, encodep)
+ Lisp_Object string, coding_system, nocopy;
+ int encodep;
+{
+ struct coding_system coding;
- validate_region (&start, &end);
- from = XFASTINT (start);
- to = XFASTINT (end);
+ CHECK_STRING (string, 0);
+ CHECK_SYMBOL (coding_system, 1);
if (NILP (coding_system))
- return make_number (to - from);
+ return (NILP (nocopy) ? Fcopy_sequence (string) : string);
if (setup_coding_system (Fcheck_coding_system (coding_system), &coding) < 0)
error ("Invalid coding system: %s", XSYMBOL (coding_system)->name->data);
coding.mode |= CODING_MODE_LAST_BLOCK;
- return code_convert_region (from, to, &coding, 1, 1);
+ Vlast_coding_system_used = coding.symbol;
+ return code_convert_string (string, &coding, encodep, !NILP (nocopy));
}
DEFUN ("decode-coding-string", Fdecode_coding_string, Sdecode_coding_string,
2, 3, 0,
"Decode STRING which is encoded in CODING-SYSTEM, and return the result.\n\
Optional arg NOCOPY non-nil means it is ok to return STRING itself\n\
-if the decoding operation is trivial.")
+if the decoding operation is trivial.\n\
+This function sets `last-coding-system-used' to the precise coding system\n\
+used (which may be different from CODING-SYSTEM if CODING-SYSTEM is\n\
+not fully specified.)")
(string, coding_system, nocopy)
Lisp_Object string, coding_system, nocopy;
{
- struct coding_system coding;
-
- CHECK_STRING (string, 0);
- CHECK_SYMBOL (coding_system, 1);
-
- if (NILP (coding_system))
- return (NILP (nocopy) ? Fcopy_sequence (string) : string);
-
- if (setup_coding_system (Fcheck_coding_system (coding_system), &coding) < 0)
- error ("Invalid coding system: %s", XSYMBOL (coding_system)->name->data);
-
- coding.mode |= CODING_MODE_LAST_BLOCK;
- return code_convert_string (string, &coding, 0, !NILP (nocopy));
+ return code_convert_string1 (string, coding_system, nocopy, 0);
}
DEFUN ("encode-coding-string", Fencode_coding_string, Sencode_coding_string,
2, 3, 0,
"Encode STRING to CODING-SYSTEM, and return the result.\n\
Optional arg NOCOPY non-nil means it is ok to return STRING itself\n\
-if the encoding operation is trivial.")
+if the encoding operation is trivial.\n\
+This function sets `last-coding-system-used' to the precise coding system\n\
+used (which may be different from CODING-SYSTEM if CODING-SYSTEM is\n\
+not fully specified.)")
(string, coding_system, nocopy)
Lisp_Object string, coding_system, nocopy;
+{
+ return code_convert_string1 (string, coding_system, nocopy, 1);
+}
+
+/* Encode or decode STRING according to CODING_SYSTEM.
+ Do not set Vlast_coding_system_used. */
+
+Lisp_Object
+code_convert_string_norecord (string, coding_system, encodep)
+ Lisp_Object string, coding_system;
+ int encodep;
{
struct coding_system coding;
CHECK_SYMBOL (coding_system, 1);
if (NILP (coding_system))
- return (NILP (nocopy) ? Fcopy_sequence (string) : string);
+ return string;
if (setup_coding_system (Fcheck_coding_system (coding_system), &coding) < 0)
error ("Invalid coding system: %s", XSYMBOL (coding_system)->name->data);
coding.mode |= CODING_MODE_LAST_BLOCK;
- return code_convert_string (string, &coding, 1, !NILP (nocopy));
+ return code_convert_string (string, &coding, encodep, Qt);
}
\f
DEFUN ("decode-sjis-char", Fdecode_sjis_char, Sdecode_sjis_char, 1, 1, 0,
- "Decode a JISX0208 character of shift-jis encoding.\n\
-CODE is the character code in SJIS.\n\
+ "Decode a Japanese character which has CODE in shift_jis encoding.\n\
Return the corresponding character.")
(code)
Lisp_Object code;
CHECK_NUMBER (code, 0);
s1 = (XFASTINT (code)) >> 8, s2 = (XFASTINT (code)) & 0xFF;
- DECODE_SJIS (s1, s2, c1, c2);
- XSETFASTINT (val, MAKE_NON_ASCII_CHAR (charset_jisx0208, c1, c2));
+ if (s1 == 0)
+ {
+ if (s2 < 0x80)
+ XSETFASTINT (val, s2);
+ else if (s2 >= 0xA0 || s2 <= 0xDF)
+ XSETFASTINT (val,
+ MAKE_NON_ASCII_CHAR (charset_katakana_jisx0201, s2, 0));
+ else
+ error ("Invalid Shift JIS code: %x", XFASTINT (code));
+ }
+ else
+ {
+ if ((s1 < 0x80 || s1 > 0x9F && s1 < 0xE0 || s1 > 0xEF)
+ || (s2 < 0x40 || s2 == 0x7F || s2 > 0xFC))
+ error ("Invalid Shift JIS code: %x", XFASTINT (code));
+ DECODE_SJIS (s1, s2, c1, c2);
+ XSETFASTINT (val, MAKE_NON_ASCII_CHAR (charset_jisx0208, c1, c2));
+ }
return val;
}
DEFUN ("encode-sjis-char", Fencode_sjis_char, Sencode_sjis_char, 1, 1, 0,
- "Encode a JISX0208 character CHAR to SJIS coding system.\n\
-Return the corresponding character code in SJIS.")
+ "Encode a Japanese character CHAR to shift_jis encoding.\n\
+Return the corresponding code in SJIS.")
(ch)
Lisp_Object ch;
{
CHECK_NUMBER (ch, 0);
SPLIT_CHAR (XFASTINT (ch), charset, c1, c2);
- if (charset == charset_jisx0208)
+ if (charset == CHARSET_ASCII)
+ {
+ val = ch;
+ }
+ else if (charset == charset_jisx0208
+ && c1 > 0x20 && c1 < 0x7F && c2 > 0x20 && c2 < 0x7F)
{
ENCODE_SJIS (c1, c2, s1, s2);
XSETFASTINT (val, (s1 << 8) | s2);
}
+ else if (charset == charset_katakana_jisx0201
+ && c1 > 0x20 && c2 < 0xE0)
+ {
+ XSETFASTINT (val, c1 | 0x80);
+ }
else
- XSETFASTINT (val, 0);
+ error ("Can't encode to shift_jis: %d", XFASTINT (ch));
return val;
}
DEFUN ("decode-big5-char", Fdecode_big5_char, Sdecode_big5_char, 1, 1, 0,
- "Decode a Big5 character CODE of BIG5 coding system.\n\
-CODE is the character code in BIG5.\n\
+ "Decode a Big5 character which has CODE in BIG5 coding system.\n\
Return the corresponding character.")
(code)
Lisp_Object code;
CHECK_NUMBER (code, 0);
b1 = (XFASTINT (code)) >> 8, b2 = (XFASTINT (code)) & 0xFF;
- DECODE_BIG5 (b1, b2, charset, c1, c2);
- XSETFASTINT (val, MAKE_NON_ASCII_CHAR (charset, c1, c2));
+ if (b1 == 0)
+ {
+ if (b2 >= 0x80)
+ error ("Invalid BIG5 code: %x", XFASTINT (code));
+ val = code;
+ }
+ else
+ {
+ if ((b1 < 0xA1 || b1 > 0xFE)
+ || (b2 < 0x40 || (b2 > 0x7E && b2 < 0xA1) || b2 > 0xFE))
+ error ("Invalid BIG5 code: %x", XFASTINT (code));
+ DECODE_BIG5 (b1, b2, charset, c1, c2);
+ XSETFASTINT (val, MAKE_NON_ASCII_CHAR (charset, c1, c2));
+ }
return val;
}
CHECK_NUMBER (ch, 0);
SPLIT_CHAR (XFASTINT (ch), charset, c1, c2);
- if (charset == charset_big5_1 || charset == charset_big5_2)
+ if (charset == CHARSET_ASCII)
+ {
+ val = ch;
+ }
+ else if ((charset == charset_big5_1
+ && (XFASTINT (ch) >= 0x250a1 && XFASTINT (ch) <= 0x271ec))
+ || (charset == charset_big5_2
+ && XFASTINT (ch) >= 0x290a1 && XFASTINT (ch) <= 0x2bdb2))
{
ENCODE_BIG5 (charset, c1, c2, b1, b2);
XSETFASTINT (val, (b1 << 8) | b2);
}
else
- XSETFASTINT (val, 0);
+ error ("Can't encode to Big5: %d", XFASTINT (ch));
return val;
}
\f
DEFUN ("find-operation-coding-system", Ffind_operation_coding_system,
Sfind_operation_coding_system, 1, MANY, 0,
"Choose a coding system for an operation based on the target name.\n\
-The value names a pair of coding systems: (DECODING-SYSTEM ENCODING-SYSTEM).\n\
+The value names a pair of coding systems: (DECODING-SYSTEM . ENCODING-SYSTEM).\n\
DECODING-SYSTEM is the coding system to use for decoding\n\
\(in case OPERATION does decoding), and ENCODING-SYSTEM is the coding system\n\
for encoding (in case OPERATION does encoding).\n\
if (NILP (chain))
return Qnil;
- for (; CONSP (chain); chain = XCONS (chain)->cdr)
+ for (; CONSP (chain); chain = XCDR (chain))
{
Lisp_Object elt;
- elt = XCONS (chain)->car;
+ elt = XCAR (chain);
if (CONSP (elt)
&& ((STRINGP (target)
- && STRINGP (XCONS (elt)->car)
- && fast_string_match (XCONS (elt)->car, target) >= 0)
- || (INTEGERP (target) && EQ (target, XCONS (elt)->car))))
+ && STRINGP (XCAR (elt))
+ && fast_string_match (XCAR (elt), target) >= 0)
+ || (INTEGERP (target) && EQ (target, XCAR (elt)))))
{
- val = XCONS (elt)->cdr;
+ val = XCDR (elt);
/* Here, if VAL is both a valid coding system and a valid
function symbol, we return VAL as a coding system. */
if (CONSP (val))
return Qnil;
}
-DEFUN ("update-iso-coding-systems", Fupdate_iso_coding_systems,
- Supdate_iso_coding_systems, 0, 0, 0,
- "Update internal database for ISO2022 based coding systems.\n\
+DEFUN ("update-coding-systems-internal", Fupdate_coding_systems_internal,
+ Supdate_coding_systems_internal, 0, 0, 0,
+ "Update internal database for ISO2022 and CCL based coding systems.\n\
When values of the following coding categories are changed, you must\n\
call this function:\n\
coding-category-iso-7, coding-category-iso-7-tight,\n\
coding-category-iso-8-1, coding-category-iso-8-2,\n\
- coding-category-iso-7-else, coding-category-iso-8-else")
+ coding-category-iso-7-else, coding-category-iso-8-else,\n\
+ coding-category-ccl")
()
{
int i;
- for (i = CODING_CATEGORY_IDX_ISO_7; i <= CODING_CATEGORY_IDX_ISO_8_ELSE;
- i++)
+ for (i = CODING_CATEGORY_IDX_ISO_7; i <= CODING_CATEGORY_IDX_CCL; i++)
+ {
+ Lisp_Object val;
+
+ val = XSYMBOL (XVECTOR (Vcoding_category_table)->contents[i])->value;
+ if (!NILP (val))
+ {
+ if (! coding_system_table[i])
+ coding_system_table[i] = ((struct coding_system *)
+ xmalloc (sizeof (struct coding_system)));
+ setup_coding_system (val, coding_system_table[i]);
+ }
+ else if (coding_system_table[i])
+ {
+ xfree (coding_system_table[i]);
+ coding_system_table[i] = NULL;
+ }
+ }
+
+ return Qnil;
+}
+
+DEFUN ("set-coding-priority-internal", Fset_coding_priority_internal,
+ Sset_coding_priority_internal, 0, 0, 0,
+ "Update internal database for the current value of `coding-category-list'.\n\
+This function is internal use only.")
+ ()
+{
+ int i = 0, idx;
+ Lisp_Object val;
+
+ val = Vcoding_category_list;
+
+ while (CONSP (val) && i < CODING_CATEGORY_IDX_MAX)
{
- if (! coding_system_table[i])
- coding_system_table[i]
- = (struct coding_system *) xmalloc (sizeof (struct coding_system));
- setup_coding_system
- (XSYMBOL (XVECTOR (Vcoding_category_table)->contents[i])->value,
- coding_system_table[i]);
+ if (! SYMBOLP (XCAR (val)))
+ break;
+ idx = XFASTINT (Fget (XCAR (val), Qcoding_category_index));
+ if (idx >= CODING_CATEGORY_IDX_MAX)
+ break;
+ coding_priorities[i++] = (1 << idx);
+ val = XCDR (val);
}
+ /* If coding-category-list is valid and contains all coding
+ categories, `i' should be CODING_CATEGORY_IDX_MAX now. If not,
+ the following code saves Emacs from craching. */
+ while (i < CODING_CATEGORY_IDX_MAX)
+ coding_priorities[i++] = CODING_CATEGORY_MASK_RAW_TEXT;
+
return Qnil;
}
#endif /* emacs */
\f
-/*** 8. Post-amble ***/
+/*** 9. Post-amble ***/
+void
+init_coding ()
+{
+ conversion_buffer = (char *) xmalloc (MINIMUM_CONVERSION_BUFFER_SIZE);
+}
+
+void
init_coding_once ()
{
int i;
iso_code_class[ISO_CODE_CSI] = ISO_control_sequence_introducer;
conversion_buffer_size = MINIMUM_CONVERSION_BUFFER_SIZE;
- conversion_buffer = (char *) xmalloc (MINIMUM_CONVERSION_BUFFER_SIZE);
setup_coding_system (Qnil, &keyboard_coding);
setup_coding_system (Qnil, &terminal_coding);
setup_coding_system (Qnil, &safe_terminal_coding);
+ setup_coding_system (Qnil, &default_buffer_file_coding);
bzero (coding_system_table, sizeof coding_system_table);
+ bzero (ascii_skip_code, sizeof ascii_skip_code);
+ for (i = 0; i < 128; i++)
+ ascii_skip_code[i] = 1;
+
#if defined (MSDOS) || defined (WINDOWSNT)
system_eol_type = CODING_EOL_CRLF;
#else
#ifdef emacs
+void
syms_of_coding ()
{
Qtarget_idx = intern ("target-idx");
}
}
- Qcharacter_unification_table = intern ("character-unification-table");
- staticpro (&Qcharacter_unification_table);
- Fput (Qcharacter_unification_table, Qchar_table_extra_slots,
- make_number (0));
+ Qtranslation_table = intern ("translation-table");
+ staticpro (&Qtranslation_table);
+ Fput (Qtranslation_table, Qchar_table_extra_slots, make_number (1));
+
+ Qtranslation_table_id = intern ("translation-table-id");
+ staticpro (&Qtranslation_table_id);
- Qcharacter_unification_table_for_decode
- = intern ("character-unification-table-for-decode");
- staticpro (&Qcharacter_unification_table_for_decode);
+ Qtranslation_table_for_decode = intern ("translation-table-for-decode");
+ staticpro (&Qtranslation_table_for_decode);
- Qcharacter_unification_table_for_encode
- = intern ("character-unification-table-for-encode");
- staticpro (&Qcharacter_unification_table_for_encode);
+ Qtranslation_table_for_encode = intern ("translation-table-for-encode");
+ staticpro (&Qtranslation_table_for_encode);
Qsafe_charsets = intern ("safe-charsets");
staticpro (&Qsafe_charsets);
+ Qvalid_codes = intern ("valid-codes");
+ staticpro (&Qvalid_codes);
+
Qemacs_mule = intern ("emacs-mule");
staticpro (&Qemacs_mule);
defsubr (&Sset_keyboard_coding_system_internal);
defsubr (&Skeyboard_coding_system);
defsubr (&Sfind_operation_coding_system);
- defsubr (&Supdate_iso_coding_systems);
+ defsubr (&Supdate_coding_systems_internal);
+ defsubr (&Sset_coding_priority_internal);
DEFVAR_LISP ("coding-system-list", &Vcoding_system_list,
"List of coding systems.\n\
DEFVAR_LISP ("coding-system-for-write", &Vcoding_system_for_write,
"Specify the coding system for write operations.\n\
-It is useful to bind this variable with `let', but do not set it globally.\n\
-If the value is a coding system, it is used for encoding on write operation.\n\
-If not, an appropriate element is used from one of the coding system alists:\n\
+Programs bind this variable with `let', but you should not set it globally.\n\
+If the value is a coding system, it is used for encoding of output,\n\
+when writing it to a file and when sending it to a file or subprocess.\n\
+\n\
+If this does not specify a coding system, an appropriate element\n\
+is used from one of the coding system alists:\n\
There are three such tables, `file-coding-system-alist',\n\
-`process-coding-system-alist', and `network-coding-system-alist'.");
+`process-coding-system-alist', and `network-coding-system-alist'.\n\
+For output to files, if the above procedure does not specify a coding system,\n\
+the value of `buffer-file-coding-system' is used.");
Vcoding_system_for_write = Qnil;
DEFVAR_LISP ("last-coding-system-used", &Vlast_coding_system_used,
Vlast_coding_system_used = Qnil;
DEFVAR_BOOL ("inhibit-eol-conversion", &inhibit_eol_conversion,
- "*Non-nil inhibit code conversion of end-of-line format in any cases.");
+ "*Non-nil means always inhibit code conversion of end-of-line format.\n\
+See info node `Coding Systems' and info node `Text and Binary' concerning\n\
+such conversion.");
inhibit_eol_conversion = 0;
+ DEFVAR_BOOL ("inherit-process-coding-system", &inherit_process_coding_system,
+ "Non-nil means process buffer inherits coding system of process output.\n\
+Bind it to t if the process output is to be treated as if it were a file\n\
+read from some filesystem.");
+ inherit_process_coding_system = 0;
+
DEFVAR_LISP ("file-coding-system-alist", &Vfile_coding_system_alist,
"Alist to decide a coding system to use for a file I/O operation.\n\
The format is ((PATTERN . VAL) ...),\n\
If VAL is a function symbol, the function must return a coding system\n\
or a cons of coding systems which are used as above.\n\
\n\
-See also the function `find-operation-coding-system'.");
+See also the function `find-operation-coding-system'\n\
+and the variable `auto-coding-alist'.");
Vfile_coding_system_alist = Qnil;
DEFVAR_LISP ("process-coding-system-alist", &Vprocess_coding_system_alist,
See also the function `find-operation-coding-system'.");
Vnetwork_coding_system_alist = Qnil;
- DEFVAR_INT ("eol-mnemonic-unix", &eol_mnemonic_unix,
- "Mnemonic character indicating UNIX-like end-of-line format (i.e. LF) .");
- eol_mnemonic_unix = ':';
+ DEFVAR_LISP ("eol-mnemonic-unix", &eol_mnemonic_unix,
+ "*String displayed in mode line for UNIX-like (LF) end-of-line format.");
+ eol_mnemonic_unix = build_string (":");
- DEFVAR_INT ("eol-mnemonic-dos", &eol_mnemonic_dos,
- "Mnemonic character indicating DOS-like end-of-line format (i.e. CRLF).");
- eol_mnemonic_dos = '\\';
+ DEFVAR_LISP ("eol-mnemonic-dos", &eol_mnemonic_dos,
+ "*String displayed in mode line for DOS-like (CRLF) end-of-line format.");
+ eol_mnemonic_dos = build_string ("\\");
- DEFVAR_INT ("eol-mnemonic-mac", &eol_mnemonic_mac,
- "Mnemonic character indicating MAC-like end-of-line format (i.e. CR).");
- eol_mnemonic_mac = '/';
+ DEFVAR_LISP ("eol-mnemonic-mac", &eol_mnemonic_mac,
+ "*String displayed in mode line for MAC-like (CR) end-of-line format.");
+ eol_mnemonic_mac = build_string ("/");
- DEFVAR_INT ("eol-mnemonic-undecided", &eol_mnemonic_undecided,
- "Mnemonic character indicating end-of-line format is not yet decided.");
- eol_mnemonic_undecided = ':';
+ DEFVAR_LISP ("eol-mnemonic-undecided", &eol_mnemonic_undecided,
+ "*String displayed in mode line when end-of-line format is not yet determined.");
+ eol_mnemonic_undecided = build_string (":");
- DEFVAR_LISP ("enable-character-unification", &Venable_character_unification,
- "Non-nil means ISO 2022 encoder/decoder do character unification.");
- Venable_character_unification = Qt;
+ DEFVAR_LISP ("enable-character-translation", &Venable_character_translation,
+ "*Non-nil enables character translation while encoding and decoding.");
+ Venable_character_translation = Qt;
- DEFVAR_LISP ("standard-character-unification-table-for-decode",
- &Vstandard_character_unification_table_for_decode,
- "Table for unifying characters when reading.");
- Vstandard_character_unification_table_for_decode = Qnil;
+ DEFVAR_LISP ("standard-translation-table-for-decode",
+ &Vstandard_translation_table_for_decode,
+ "Table for translating characters while decoding.");
+ Vstandard_translation_table_for_decode = Qnil;
- DEFVAR_LISP ("standard-character-unification-table-for-encode",
- &Vstandard_character_unification_table_for_encode,
- "Table for unifying characters when writing.");
- Vstandard_character_unification_table_for_encode = Qnil;
+ DEFVAR_LISP ("standard-translation-table-for-encode",
+ &Vstandard_translation_table_for_encode,
+ "Table for translationg characters while encoding.");
+ Vstandard_translation_table_for_encode = Qnil;
DEFVAR_LISP ("charset-revision-table", &Vcharset_revision_alist,
"Alist of charsets vs revision numbers.\n\
coding system which can encode the text in the case that a default\n\
coding system used in each operation can't encode the text.\n\
\n\
-The default value is `select-safe-codign-system' (which see).");
+The default value is `select-safe-coding-system' (which see).");
Vselect_safe_coding_system_function = Qnil;
}
HCoop / bpt / emacs.git / blobdiff