/* Decode one ASCII character C. */
-#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; \
- } \
+#define DECODE_CHARACTER_ASCII(c) \
+ do { \
+ *dst++ = (c) & 0x7F; \
+ coding->produced_char++; \
} while (0)
/* Decode one DIMENSION1 character whose charset is CHARSET and whose
#define DECODE_CHARACTER_DIMENSION1(charset, c) \
do { \
unsigned char leading_code = CHARSET_LEADING_CODE_BASE (charset); \
- if (COMPOSING_P (coding->composing)) \
- { \
- *dst++ = leading_code + 0x20; \
- coding->composed_chars++; \
- } \
- else \
- { \
- *dst++ = leading_code; \
- coding->produced_char++; \
- } \
- if (leading_code = CHARSET_LEADING_CODE_EXT (charset)) \
+ \
+ *dst++ = leading_code; \
+ if ((leading_code = CHARSET_LEADING_CODE_EXT (charset)) > 0) \
*dst++ = leading_code; \
*dst++ = (c) | 0x80; \
- if (((c) | 0x80) < 0xA0) \
- coding->fake_multibyte = 1; \
+ coding->produced_char++; \
} 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
/*** 1. Preamble ***/
+#ifdef emacs
+#include <config.h>
+#endif
+
#include <stdio.h>
#ifdef emacs
-#include <config.h>
#include "lisp.h"
#include "buffer.h"
#include "charset.h"
+#include "composite.h"
#include "ccl.h"
#include "coding.h"
#include "window.h"
Lisp_Object Vprocess_coding_system_alist;
Lisp_Object Vnetwork_coding_system_alist;
+Lisp_Object Vlocale_coding_system;
+
#endif /* emacs */
Lisp_Object Qcoding_category, Qcoding_category_index;
/* Default coding systems used for process I/O. */
Lisp_Object Vdefault_process_coding_system;
+/* Global flag to tell that we can't call post-read-conversion and
+ pre-write-conversion functions. Usually the value is zero, but it
+ is set to 1 temporarily while such functions are running. This is
+ to avoid infinite recursive call. */
+static int inhibit_pre_post_conversion;
+
\f
/*** 2. Emacs internal format (emacs-mule) handlers ***/
the range 0xA0 through 0xFF. See `charset.h' for more details
about leading-code and position-code.
- There's one exception to this rule. Special leading-code
- `leading-code-composition' denotes that the following several
- characters should be composed into one character. Leading-codes of
- components (except for ASCII) are added 0x20. An ASCII character
- component is represented by a 2-byte sequence of `0xA0' and
- `ASCII-code + 0x80'. See also the comments in `charset.h' for the
- details of composite character. Hence, we can summarize the code
- range as follows:
-
--- CODE RANGE of Emacs' internal format ---
(character set) (range)
ASCII 0x00 .. 0x7F
- ELSE (1st byte) 0x80 .. 0x9F
+ ELSE (1st byte) 0x81 .. 0x9F
(rest bytes) 0xA0 .. 0xFF
---------------------------------------------
case EMACS_invalid_code:
return 0;
- case EMACS_leading_code_composition: /* c == 0x80 */
- if (composing)
- CHECK_CODE_RANGE_A0_FF;
- else
- composing = 1;
- break;
-
case EMACS_leading_code_4:
CHECK_CODE_RANGE_A0_FF;
/* fall down to check it two more times ... */
CHECK_CODE_RANGE_A0_FF;
break;
+ case 0x80: /* Old leading code for a composite character. */
+ if (composing)
+ CHECK_CODE_RANGE_A0_FF;
+ else
+ composing = 1;
+ break;
+
default:
label_end_of_switch:
break;
/*** 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:
- 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. */
+ abbreviated to the escape sequence ESC '[' in a 7-bit environment.
+
+ Character composition specification takes the following form:
+ o ESC '0' -- start relative composition
+ o ESC '1' -- end composition
+ o ESC '2' -- start rule-base composition (*)
+ o ESC '3' -- start relative composition with alternate chars (**)
+ o ESC '4' -- start rule-base composition with alternate chars (**)
+ Since these are not standard escape sequences of any ISO standard,
+ the use of them for these meaning is restricted to Emacs only.
+
+ (*) This form is used only in Emacs 20.5 and the older versions,
+ but the newer versions can safely decode it.
+ (**) This form is used only in Emacs 21.1 and the newer versions,
+ and the older versions can't decode it.
+
+ Here's a list of examples usages of these composition escape
+ sequences (categorized by `enum composition_method').
+
+ COMPOSITION_RELATIVE:
+ ESC 0 CHAR [ CHAR ] ESC 1
+ COMPOSITOIN_WITH_RULE:
+ ESC 2 CHAR [ RULE CHAR ] ESC 1
+ COMPOSITION_WITH_ALTCHARS:
+ ESC 3 ALTCHAR [ ALTCHAR ] ESC 0 CHAR [ CHAR ] ESC 1
+ COMPOSITION_WITH_RULE_ALTCHARS:
+ ESC 4 ALTCHAR [ RULE ALTCHAR ] ESC 0 CHAR [ CHAR ] ESC 1 */
enum iso_code_class_type iso_code_class[256];
mask &= CODING_CATEGORY_MASK_ISO_7_ELSE;
break;
}
- else if (c == '0' || c == '1' || c == '2')
- /* ESC <Fp> for start/end composition. Just ignore. */
- break;
+ else if (c >= '0' && c <= '4')
+ {
+ /* ESC <Fp> for start/end composition. */
+ mask_found |= CODING_CATEGORY_MASK_ISO;
+ break;
+ }
else
/* Invalid escape sequence. Just ignore. */
break;
code is C1. If dimension of CHARSET is 2, the 2nd position code is
fetched from SRC and set to C2. If CHARSET is negative, it means
that we are decoding ill formed text, and what we can do is just to
- read C1 as is. */
-
-#define DECODE_ISO_CHARACTER(charset, c1) \
- do { \
- int c_alt, charset_alt = (charset); \
- if (COMPOSING_HEAD_P (coding->composing)) \
- { \
- *dst++ = LEADING_CODE_COMPOSITION; \
- if (COMPOSING_WITH_RULE_P (coding->composing)) \
- /* To tell composition rules are embeded. */ \
- *dst++ = 0xFF; \
- coding->composing += 2; \
- } \
- if (charset_alt >= 0) \
- { \
- 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--; \
- charset_alt = CHARSET_ASCII; \
- } \
- } \
- if (!NILP (translation_table) \
- && ((c_alt = translate_char (translation_table, \
+ read C1 as is.
+
+ If we are now in the middle of composition sequence, the decoded
+ character may be ALTCHAR (see the comment above). In that case,
+ the character goes to coding->cmp_data->data instead of DST. */
+
+#define DECODE_ISO_CHARACTER(charset, c1) \
+ do { \
+ int c_alt = -1, charset_alt = (charset); \
+ if (charset_alt >= 0) \
+ { \
+ 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--; \
+ charset_alt = CHARSET_ASCII; \
+ } \
+ } \
+ 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) \
- 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); \
- if (COMPOSING_WITH_RULE_P (coding->composing)) \
- /* To tell a composition rule follows. */ \
- coding->composing = COMPOSING_WITH_RULE_RULE; \
+ SPLIT_CHAR (c_alt, charset_alt, c1, c2); \
+ } \
+ if (! COMPOSING_P (coding) \
+ || coding->composing == COMPOSITION_RELATIVE \
+ || coding->composing == COMPOSITION_WITH_RULE) \
+ { \
+ 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); \
+ } \
+ if (COMPOSING_P (coding) \
+ && coding->composing != COMPOSITION_RELATIVE) \
+ { \
+ if (c_alt < 0) \
+ c_alt = MAKE_CHAR (charset_alt, c1, c2); \
+ CODING_ADD_COMPOSITION_COMPONENT (coding, c_alt); \
+ coding->composition_rule_follows \
+ = coding->composing != COMPOSITION_WITH_ALTCHARS; \
+ } \
} while (0)
/* Set designation state into CODING. */
} \
} while (0)
-/* Return 0 if there's a valid composing sequence starting at SRC and
- ending before SRC_END, else return -1. */
+/* Allocate a memory block for storing information about compositions.
+ The block is chained to the already allocated blocks. */
-int
-check_composing_code (coding, src, src_end)
+static void
+coding_allocate_composition_data (coding, char_offset)
struct coding_system *coding;
- unsigned char *src, *src_end;
+ int char_offset;
{
- int charset, c, c1, dim;
+ struct composition_data *cmp_data
+ = (struct composition_data *) xmalloc (sizeof *cmp_data);
+
+ cmp_data->char_offset = char_offset;
+ cmp_data->used = 0;
+ cmp_data->prev = coding->cmp_data;
+ cmp_data->next = NULL;
+ if (coding->cmp_data)
+ coding->cmp_data->next = cmp_data;
+ coding->cmp_data = cmp_data;
+ coding->cmp_data_start = 0;
+}
- while (src < src_end)
- {
- 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 <= '/')
- {
- 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;
- }
+/* Record the starting position START and METHOD of one composition. */
+
+#define CODING_ADD_COMPOSITION_START(coding, start, method) \
+ do { \
+ struct composition_data *cmp_data = coding->cmp_data; \
+ int *data = cmp_data->data + cmp_data->used; \
+ coding->cmp_data_start = cmp_data->used; \
+ data[0] = -1; \
+ data[1] = cmp_data->char_offset + start; \
+ data[3] = (int) method; \
+ cmp_data->used += 4; \
+ } while (0)
+
+/* Record the ending position END of the current composition. */
+
+#define CODING_ADD_COMPOSITION_END(coding, end) \
+ do { \
+ struct composition_data *cmp_data = coding->cmp_data; \
+ int *data = cmp_data->data + coding->cmp_data_start; \
+ data[0] = cmp_data->used - coding->cmp_data_start; \
+ data[2] = cmp_data->char_offset + end; \
+ } while (0)
+
+/* Record one COMPONENT (alternate character or composition rule). */
+
+#define CODING_ADD_COMPOSITION_COMPONENT(coding, component) \
+ (coding->cmp_data->data[coding->cmp_data->used++] = component)
+
+/* Handle compositoin start sequence ESC 0, ESC 2, ESC 3, or ESC 4. */
+
+#define DECODE_COMPOSITION_START(c1) \
+ do { \
+ if (coding->composing == COMPOSITION_DISABLED) \
+ { \
+ *dst++ = ISO_CODE_ESC; \
+ *dst++ = c1 & 0x7f; \
+ coding->produced_char += 2; \
+ } \
+ else if (!COMPOSING_P (coding)) \
+ { \
+ /* This is surely the start of a composition. We must be sure \
+ that coding->cmp_data has enough space to store the \
+ information about the composition. If not, terminate the \
+ current decoding loop, allocate one more memory block for \
+ coding->cmp_data in the calller, then start the decoding \
+ loop again. We can't allocate memory here directly because \
+ it may cause buffer/string relocation. */ \
+ if (coding->cmp_data->used + COMPOSITION_DATA_MAX_BUNCH_LENGTH \
+ >= COMPOSITION_DATA_SIZE) \
+ { \
+ result = CODING_FINISH_INSUFFICIENT_CMP; \
+ goto label_end_of_loop_2; \
+ } \
+ coding->composing = (c1 == '0' ? COMPOSITION_RELATIVE \
+ : c1 == '2' ? COMPOSITION_WITH_RULE \
+ : c1 == '3' ? COMPOSITION_WITH_ALTCHARS \
+ : COMPOSITION_WITH_RULE_ALTCHARS); \
+ CODING_ADD_COMPOSITION_START (coding, coding->produced_char, \
+ coding->composing); \
+ coding->composition_rule_follows = 0; \
+ } \
+ else \
+ { \
+ /* We are already handling a composition. If the method is \
+ the following two, the codes following the current escape \
+ sequence are actual characters stored in a buffer. */ \
+ if (coding->composing == COMPOSITION_WITH_ALTCHARS \
+ || coding->composing == COMPOSITION_WITH_RULE_ALTCHARS) \
+ { \
+ coding->composing = COMPOSITION_RELATIVE; \
+ coding->composition_rule_follows = 0; \
+ } \
+ } \
+ } while (0)
+
+/* Handle compositoin end sequence ESC 1. */
+
+#define DECODE_COMPOSITION_END(c1) \
+ do { \
+ if (coding->composing == COMPOSITION_DISABLED) \
+ { \
+ *dst++ = ISO_CODE_ESC; \
+ *dst++ = c1; \
+ coding->produced_char += 2; \
+ } \
+ else \
+ { \
+ CODING_ADD_COMPOSITION_END (coding, coding->produced_char); \
+ coding->composing = COMPOSITION_NO; \
+ } \
+ } while (0)
+
+/* Decode a composition rule from the byte C1 (and maybe one more byte
+ from SRC) and store one encoded composition rule in
+ coding->cmp_data. */
+
+#define DECODE_COMPOSITION_RULE(c1) \
+ do { \
+ int rule = 0; \
+ (c1) -= 32; \
+ if (c1 < 81) /* old format (before ver.21) */ \
+ { \
+ int gref = (c1) / 9; \
+ int nref = (c1) % 9; \
+ if (gref == 4) gref = 10; \
+ if (nref == 4) nref = 10; \
+ rule = COMPOSITION_ENCODE_RULE (gref, nref); \
+ } \
+ else if (c1 < 93) /* new format (after ver.21 */ \
+ { \
+ ONE_MORE_BYTE (c2); \
+ rule = COMPOSITION_ENCODE_RULE (c1 - 81, c2 - 32); \
+ } \
+ CODING_ADD_COMPOSITION_COMPONENT (coding, rule); \
+ coding->composition_rule_follows = 0; \
+ } while (0)
- /* We have not found the sequence "ESC 1". */
- return -1;
-}
/* See the above "GENERAL NOTES on `decode_coding_XXX ()' functions". */
unsigned char *src_base = src;
int c1 = *src++, c2;
+ /* We produce no character or one character. */
switch (iso_code_class [c1])
{
case ISO_0x20_or_0x7F:
- if (!coding->composing
- && (charset0 < 0 || CHARSET_CHARS (charset0) == 94))
+ if (COMPOSING_P (coding) && coding->composition_rule_follows)
+ {
+ DECODE_COMPOSITION_RULE (c1);
+ break;
+ }
+ if (charset0 < 0 || CHARSET_CHARS (charset0) == 94)
{
/* This is SPACE or DEL. */
*dst++ = c1;
/* This is a graphic character, we fall down ... */
case ISO_graphic_plane_0:
- if (coding->composing == COMPOSING_WITH_RULE_RULE)
- {
- /* This is a composition rule. */
- *dst++ = c1 | 0x80;
- coding->composing = COMPOSING_WITH_RULE_TAIL;
- }
+ if (COMPOSING_P (coding) && coding->composition_rule_follows)
+ DECODE_COMPOSITION_RULE (c1);
else
DECODE_ISO_CHARACTER (charset0, c1);
break;
case ISO_graphic_plane_1:
if (coding->flags & CODING_FLAG_ISO_SEVEN_BITS)
goto label_invalid_code;
- else
- DECODE_ISO_CHARACTER (charset1, c1);
+ DECODE_ISO_CHARACTER (charset1, c1);
break;
case ISO_control_code:
+ if (COMPOSING_P (coding))
+ DECODE_COMPOSITION_END ('1');
+
/* All ISO2022 control characters in this class have the
same representation in Emacs internal format. */
if (c1 == '\n'
}
*dst++ = c1;
coding->produced_char++;
- if (c1 >= 0x80)
- coding->fake_multibyte = 1;
break;
case ISO_carriage_return:
+ if (COMPOSING_P (coding))
+ DECODE_COMPOSITION_END ('1');
+
if (coding->eol_type == CODING_EOL_CR)
*dst++ = '\n';
else if (coding->eol_type == CODING_EOL_CRLF)
DECODE_ISO_CHARACTER (charset, c1);
break;
- 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. */
- 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);
- coding->composed_chars = 0;
- }
- else
- {
- *dst++ = ISO_CODE_ESC;
- *dst++ = c1;
- coding->produced_char += 2;
- }
+ case '0': case '2': case '3': case '4': /* start composition */
+ DECODE_COMPOSITION_START (c1);
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;
+ case '1': /* end composition */
+ DECODE_COMPOSITION_END (c1);
break;
case '[': /* specification of direction */
break;
label_invalid_code:
+ if (COMPOSING_P (coding))
+ DECODE_COMPOSITION_END ('1');
+ coding->produced_char += src - src_base;
while (src_base < src)
- *dst++ = *src_base++;
- coding->fake_multibyte = 1;
+ *dst++ = (*src_base++) & 0x7F;
}
continue;
/* 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 (COMPOSING_P (coding))
+ DECODE_COMPOSITION_END ('1');
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;
+ if (dst_bytes && (dst_end - dst < src_end - src))
+ src_end = src + (dst_end - dst);
+ coding->produced_char += src_end - src;
+ while (src < src_end)
+ *dst++ = (*src++) & 0x7F;
}
}
dst = encode_invocation_designation (charset, coding, dst); \
} while (1)
-#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_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); \
- } \
- 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; \
+ } \
+ } \
+ coding->consumed_char++; \
} while (0)
/* Produce designation and invocation codes at a place pointed by DST
return dst;
}
-/* The following two macros produce codes for indicating composition. */
-#define ENCODE_COMPOSITION_NO_RULE_START *dst++ = ISO_CODE_ESC, *dst++ = '0'
-#define ENCODE_COMPOSITION_WITH_RULE_START *dst++ = ISO_CODE_ESC, *dst++ = '2'
-#define ENCODE_COMPOSITION_END *dst++ = ISO_CODE_ESC, *dst++ = '1'
+/* Produce 2-byte codes for encoded composition rule RULE. */
+
+#define ENCODE_COMPOSITION_RULE(rule) \
+ do { \
+ int gref, nref; \
+ COMPOSITION_DECODE_RULE (rule, gref, nref); \
+ *dst++ = 32 + 81 + gref; \
+ *dst++ = 32 + nref; \
+ } while (0)
+
+/* Produce codes for indicating the start of a composition sequence
+ (ESC 0, ESC 3, or ESC 4). DATA points to an array of integers
+ which specify information about the composition. See the comment
+ in coding.h for the format of DATA. */
+
+#define ENCODE_COMPOSITION_START(coding, data) \
+ do { \
+ coding->composing = data[3]; \
+ *dst++ = ISO_CODE_ESC; \
+ if (coding->composing == COMPOSITION_RELATIVE) \
+ *dst++ = '0'; \
+ else \
+ { \
+ *dst++ = (coding->composing == COMPOSITION_WITH_ALTCHARS \
+ ? '3' : '4'); \
+ coding->cmp_data_index = coding->cmp_data_start + 4; \
+ coding->composition_rule_follows = 0; \
+ } \
+ } while (0)
+
+/* Produce codes for indicating the end of the current composition. */
+
+#define ENCODE_COMPOSITION_END(coding, data) \
+ do { \
+ *dst++ = ISO_CODE_ESC; \
+ *dst++ = '1'; \
+ coding->cmp_data_start += data[0]; \
+ coding->composing = COMPOSITION_NO; \
+ if (coding->cmp_data_start == coding->cmp_data->used \
+ && coding->cmp_data->next) \
+ { \
+ coding->cmp_data = coding->cmp_data->next; \
+ coding->cmp_data_start = 0; \
+ } \
+ } while (0)
+
+/* Produce composition start sequence ESC 0. Here, this sequence
+ doesn't mean the start of a new composition but means that we have
+ just produced components (alternate chars and composition rules) of
+ the composition and the actual text follows in SRC. */
+
+#define ENCODE_COMPOSITION_FAKE_START(coding) \
+ do { \
+ *dst++ = ISO_CODE_ESC; \
+ *dst++ = '0'; \
+ coding->composing = COMPOSITION_RELATIVE; \
+ } while (0)
/* The following three macros produce codes for indicating direction
of text. */
unsigned char *src_end = source + src_bytes;
unsigned char *dst = destination;
unsigned char *dst_end = destination + dst_bytes;
- /* Since the maximum bytes produced by each loop is 20, we subtract 19
+ /* Since the maximum bytes produced by each loop is 14, we subtract 13
from DST_END to assure overflow checking is necessary only at the
head of loop. */
- unsigned char *adjusted_dst_end = dst_end - 19;
+ unsigned char *adjusted_dst_end = dst_end - 13;
Lisp_Object translation_table
= coding->translation_table_for_encode;
int result = CODING_FINISH_NORMAL;
coding->fake_multibyte = 0;
while (src < src_end && (dst_bytes
? (dst < adjusted_dst_end)
- : (dst < src - 19)))
+ : (dst < src - 13)))
{
/* SRC_BASE remembers the start position in source in each loop.
The loop will be exited when there's not enough source text
CODING_SPEC_ISO_BOL (coding) = 0;
}
- c1 = *src++;
- /* If we are seeing a component of a composite character, we are
- seeing a leading-code encoded irregularly for composition, or
- a composition rule if composing with rule. We must set C1 to
- a normal leading-code or an ASCII code. If we are not seeing
- a composite character, we must reset composition,
- designation, and invocation states. */
- if (COMPOSING_P (coding->composing))
+ /* Check composition start and end. */
+ if (coding->composing != COMPOSITION_DISABLED
+ && coding->cmp_data_start < coding->cmp_data->used)
{
- if (c1 < 0xA0)
+ struct composition_data *cmp_data = coding->cmp_data;
+ int *data = cmp_data->data + coding->cmp_data_start;
+ int this_pos = cmp_data->char_offset + coding->consumed_char;
+
+ if (coding->composing == COMPOSITION_RELATIVE)
{
- /* We are not in a composite character any longer. */
- coding->composing = COMPOSING_NO;
- ENCODE_RESET_PLANE_AND_REGISTER;
- ENCODE_COMPOSITION_END;
+ if (this_pos == data[2])
+ {
+ ENCODE_COMPOSITION_END (coding, data);
+ cmp_data = coding->cmp_data;
+ data = cmp_data->data + coding->cmp_data_start;
+ }
}
- else
+ else if (COMPOSING_P (coding))
{
- if (coding->composing == COMPOSING_WITH_RULE_RULE)
+ /* COMPOSITION_WITH_ALTCHARS or COMPOSITION_WITH_RULE_ALTCHAR */
+ if (coding->cmp_data_index == coding->cmp_data_start + data[0])
+ /* We have consumed components of the composition.
+ What follows in SRC is the compositions's base
+ text. */
+ ENCODE_COMPOSITION_FAKE_START (coding);
+ else
{
- *dst++ = c1 & 0x7F;
- coding->composing = COMPOSING_WITH_RULE_HEAD;
+ int c = cmp_data->data[coding->cmp_data_index++];
+ if (coding->composition_rule_follows)
+ {
+ ENCODE_COMPOSITION_RULE (c);
+ coding->composition_rule_follows = 0;
+ }
+ else
+ {
+ SPLIT_CHAR (c, charset, c1, c2);
+ ENCODE_ISO_CHARACTER (charset, c1, c2);
+ /* But, we didn't consume a character in SRC. */
+ coding->consumed_char--;
+ if (coding->composing == COMPOSITION_WITH_RULE_ALTCHARS)
+ coding->composition_rule_follows = 1;
+ }
continue;
}
- else if (coding->composing == COMPOSING_WITH_RULE_HEAD)
- coding->composing = COMPOSING_WITH_RULE_RULE;
- if (c1 == 0xA0)
+ }
+ if (!COMPOSING_P (coding))
+ {
+ if (this_pos == data[1])
{
- /* This is an ASCII component. */
- ONE_MORE_BYTE (c1);
- c1 &= 0x7F;
+ ENCODE_COMPOSITION_START (coding, data);
+ continue;
}
- else
- /* This is a leading-code of non ASCII component. */
- c1 -= 0x20;
}
}
-
+
+ c1 = *src++;
/* Now encode one character. C1 is a control character, an
ASCII character, or a leading-code of multi-byte character. */
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 */
case EMACS_leading_code_3:
TWO_MORE_BYTES (c2, c3);
+ c4 = 0;
if (c2 < 0xA0 || c3 < 0xA0)
{
/* invalid sequence */
ENCODE_ISO_CHARACTER (c2, c3, c4);
break;
- case EMACS_leading_code_composition:
- ONE_MORE_BYTE (c2);
- if (c2 < 0xA0)
- {
- /* invalid sequence */
- *dst++ = c1;
- src--;
- coding->consumed_char++;
- }
- else if (c2 == 0xFF)
- {
- ENCODE_RESET_PLANE_AND_REGISTER;
- coding->composing = COMPOSING_WITH_RULE_HEAD;
- ENCODE_COMPOSITION_WITH_RULE_START;
- coding->consumed_char++;
- }
- else
- {
- ENCODE_RESET_PLANE_AND_REGISTER;
- /* Rewind one byte because it is a character code of
- composition elements. */
- src--;
- coding->composing = COMPOSING_NO_RULE_HEAD;
- ENCODE_COMPOSITION_NO_RULE_START;
- coding->consumed_char++;
- }
- break;
-
case EMACS_invalid_code:
if (coding->flags & CODING_FLAG_ISO_RESET_AT_CNTL)
ENCODE_RESET_PLANE_AND_REGISTER;
if (coding->mode & CODING_MODE_LAST_BLOCK)
{
ENCODE_RESET_PLANE_AND_REGISTER;
- if (COMPOSING_P (coding->composing))
- ENCODE_COMPOSITION_END;
+ if (COMPOSING_P (coding))
+ *dst++ = ISO_CODE_ESC, *dst++ = '1';
if (result == CODING_FINISH_INSUFFICIENT_SRC)
{
while (src < src_end && dst < dst_end)
(character set) (range)
ASCII 0x00 .. 0x7F
KATAKANA-JISX0201 0xA0 .. 0xDF
- JISX0208 (1st byte) 0x80 .. 0x9F and 0xE0 .. 0xEF
+ JISX0208 (1st byte) 0x81 .. 0x9F and 0xE0 .. 0xEF
(2nd byte) 0x40 .. 0x7E and 0x80 .. 0xFC
-------------------------------
{ \
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; \
else \
{ \
c1 &= 0x7F, c2 &= 0x7F; \
- if (sjis_p && charset_alt == charset_jisx0208) \
+ if (sjis_p && (charset_alt == charset_jisx0208 \
+ || charset_alt == charset_jisx0208_1978))\
{ \
unsigned char s1, s2; \
\
} \
} \
coding->consumed_char++; \
- } while (0);
+ } while (0)
/* See the above "GENERAL NOTES on `detect_coding_XXX ()' functions".
Check if a text is encoded in SJIS. If it is, return
coding->produced_char++;
}
else if (c1 < 0x80)
- DECODE_SJIS_BIG5_CHARACTER (charset_ascii, c1, /* dummy */ c2);
+ {
+ c2 = 0; /* avoid warning */
+ DECODE_SJIS_BIG5_CHARACTER (charset_ascii, c1, /* dummy */ c2);
+ }
else
{
if (sjis_p)
}
else if (c1 < 0xE0)
/* SJIS -> JISX0201-Kana */
- DECODE_SJIS_BIG5_CHARACTER (charset_katakana_jisx0201, c1,
- /* dummy */ c2);
+ {
+ c2 = 0; /* avoid warning */
+ DECODE_SJIS_BIG5_CHARACTER (charset_katakana_jisx0201, c1,
+ /* dummy */ c2);
+ }
else
goto label_invalid_code_1;
}
unsigned char *src_base = src;
unsigned char c1 = *src++, c2, c3, c4;
- if (coding->composing)
- {
- if (c1 == 0xA0)
- {
- ONE_MORE_BYTE (c1);
- c1 &= 0x7F;
- }
- else if (c1 >= 0xA0)
- c1 -= 0x20;
- else
- coding->composing = 0;
- }
-
switch (emacs_code_class[c1])
{
case EMACS_ascii_code:
ENCODE_SJIS_BIG5_CHARACTER (c2, c3, c4);
break;
- case EMACS_leading_code_composition:
- coding->composing = 1;
- break;
-
default: /* i.e. case EMACS_invalid_code: */
*dst++ = c1;
coding->consumed_char++;
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)
{
coding->mode = 0;
coding->heading_ascii = -1;
coding->post_read_conversion = coding->pre_write_conversion = Qnil;
+ coding->composing = COMPOSITION_DISABLED;
+ coding->cmp_data = NULL;
+
+ 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]))
return 0;
}
- /* Initialize remaining fields. */
- coding->composing = 0;
- coding->composed_chars = 0;
-
/* Get values of coding system properties:
`post-read-conversion', `pre-write-conversion',
`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);
+ /* Pre & post conversion functions should be disabled if
+ inhibit_eol_conversion is nozero. This is the case that a code
+ conversion function is called while those functions are running. */
+ if (! inhibit_pre_post_conversion)
+ {
+ coding->post_read_conversion = Fplist_get (plist, Qpost_read_conversion);
+ coding->pre_write_conversion = Fplist_get (plist, Qpre_write_conversion);
+ }
val = Fplist_get (plist, Qtranslation_table_for_decode);
if (SYMBOLP (val))
val = Fget (val, Qtranslation_table_for_decode);
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);
}
}
+ /* If the coding system has non-nil `composition' property, enable
+ composition handling. */
+ val = Fplist_get (plist, Qcomposition);
+ if (!NILP (val))
+ coding->composing = COMPOSITION_NO;
+
switch (XFASTINT (coding_type))
{
case 0:
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.
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;
- Lisp_Object decoder, encoder;
-
val = XVECTOR (coding_spec)->contents[4];
- if (CONSP (val)
- && SYMBOLP (XCONS (val)->car)
- && !NILP (decoder = Fget (XCONS (val)->car, Qccl_program_idx))
- && !NILP (decoder = Fcdr (Faref (Vccl_program_table, decoder)))
- && SYMBOLP (XCONS (val)->cdr)
- && !NILP (encoder = Fget (XCONS (val)->cdr, Qccl_program_idx))
- && !NILP (encoder = Fcdr (Faref (Vccl_program_table, encoder))))
- {
- setup_ccl_program (&(coding->spec.ccl.decoder), decoder);
- setup_ccl_program (&(coding->spec.ccl.encoder), encoder);
- }
- else
+ 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);
{
Lisp_Object this;
- for (; CONSP (val); val = XCONS (val)->cdr)
+ for (; CONSP (val); val = XCDR (val))
{
- this = XCONS (val)->car;
+ 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 (XCONS (this)->car)
- && INTEGERP (XCONS (this)->cdr))
+ && INTEGERP (XCAR (this))
+ && INTEGERP (XCDR (this)))
{
- int start = XINT (XCONS (this)->car);
- int end = XINT (XCONS (this)->cdr);
+ int start = XINT (XCAR (this));
+ int end = XINT (XCDR (this));
if (start >= 0 && start <= end && end < 256)
while (start <= end)
return -1;
}
+/* Free memory blocks allocated for storing composition information. */
+
+void
+coding_free_composition_data (coding)
+ struct coding_system *coding;
+{
+ struct composition_data *cmp_data = coding->cmp_data, *next;
+
+ if (!cmp_data)
+ return;
+ /* Memory blocks are chained. At first, rewind to the first, then,
+ free blocks one by one. */
+ while (cmp_data->prev)
+ cmp_data = cmp_data->prev;
+ while (cmp_data)
+ {
+ next = cmp_data->next;
+ xfree (cmp_data);
+ cmp_data = next;
+ }
+ coding->cmp_data = NULL;
+}
+
+/* Set `char_offset' member of all memory blocks pointed by
+ coding->cmp_data to POS. */
+
+void
+coding_adjust_composition_offset (coding, pos)
+ struct coding_system *coding;
+ int pos;
+{
+ struct composition_data *cmp_data;
+
+ for (cmp_data = coding->cmp_data; cmp_data; cmp_data = cmp_data->next)
+ cmp_data->char_offset = pos;
+}
+
/* 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
coding->symbol
= XVECTOR (subsidiaries)->contents[coding->eol_type];
}
+ setup_coding_system (coding->symbol, coding);
}
return;
}
/* 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)
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)
} \
} while (0)
+static Lisp_Object
+code_convert_region_unwind (dummy)
+ Lisp_Object dummy;
+{
+ inhibit_pre_post_conversion = 0;
+ return Qnil;
+}
+
+/* Store information about all compositions in the range FROM and TO
+ of OBJ in memory blocks pointed by CODING->cmp_data. OBJ is a
+ buffer or a string, defaults to the current buffer. */
+
+void
+coding_save_composition (coding, from, to, obj)
+ struct coding_system *coding;
+ int from, to;
+ Lisp_Object obj;
+{
+ Lisp_Object prop;
+ int start, end;
+
+ coding->composing = COMPOSITION_DISABLED;
+ if (!find_composition (from, to, &start, &end, &prop, obj)
+ || end > to)
+ return;
+ if (start < from
+ && (!find_composition (end, to, &start, &end, &prop, obj)
+ || end > to))
+ return;
+ coding->composing = COMPOSITION_NO;
+ coding_allocate_composition_data (coding, from);
+ do
+ {
+ if (COMPOSITION_VALID_P (start, end, prop))
+ {
+ enum composition_method method = COMPOSITION_METHOD (prop);
+ if (coding->cmp_data->used + COMPOSITION_DATA_MAX_BUNCH_LENGTH
+ >= COMPOSITION_DATA_SIZE)
+ coding_allocate_composition_data (coding, from);
+ /* For relative composition, we remember start and end
+ positions, for the other compositions, we also remember
+ components. */
+ CODING_ADD_COMPOSITION_START (coding, start - from, method);
+ if (method != COMPOSITION_RELATIVE)
+ {
+ /* We must store a*/
+ Lisp_Object val, ch;
+
+ val = COMPOSITION_COMPONENTS (prop);
+ if (CONSP (val))
+ while (CONSP (val))
+ {
+ ch = XCAR (val), val = XCDR (val);
+ CODING_ADD_COMPOSITION_COMPONENT (coding, XINT (ch));
+ }
+ else if (VECTORP (val) || STRINGP (val))
+ {
+ int len = (VECTORP (val)
+ ? XVECTOR (val)->size : XSTRING (val)->size);
+ int i;
+ for (i = 0; i < len; i++)
+ {
+ ch = (STRINGP (val)
+ ? Faref (val, make_number (i))
+ : XVECTOR (val)->contents[i]);
+ CODING_ADD_COMPOSITION_COMPONENT (coding, XINT (ch));
+ }
+ }
+ else /* INTEGERP (val) */
+ CODING_ADD_COMPOSITION_COMPONENT (coding, XINT (val));
+ }
+ CODING_ADD_COMPOSITION_END (coding, end - from);
+ }
+ start = end;
+ }
+ while (start < to
+ && find_composition (start, to, &start, &end, &prop, obj)
+ && end <= to);
+
+ /* Make coding->cmp_data point to the first memory block. */
+ while (coding->cmp_data->prev)
+ coding->cmp_data = coding->cmp_data->prev;
+ coding->cmp_data_start = 0;
+}
+
+/* Reflect the saved information about compositions to OBJ.
+ CODING->cmp_data points to a memory block for the informaiton. OBJ
+ is a buffer or a string, defaults to the current buffer. */
+
+static void
+coding_restore_composition (coding, obj)
+ struct coding_system *coding;
+ Lisp_Object obj;
+{
+ struct composition_data *cmp_data = coding->cmp_data;
+
+ if (!cmp_data)
+ return;
+
+ while (cmp_data->prev)
+ cmp_data = cmp_data->prev;
+
+ while (cmp_data)
+ {
+ int i;
+
+ for (i = 0; i < cmp_data->used; i += cmp_data->data[i])
+ {
+ int *data = cmp_data->data + i;
+ enum composition_method method = (enum composition_method) data[3];
+ Lisp_Object components;
+
+ if (method == COMPOSITION_RELATIVE)
+ components = Qnil;
+ else
+ {
+ int len = data[0] - 4, j;
+ Lisp_Object args[MAX_COMPOSITION_COMPONENTS * 2 - 1];
+
+ for (j = 0; j < len; j++)
+ args[j] = make_number (data[4 + j]);
+ components = (method == COMPOSITION_WITH_ALTCHARS
+ ? Fstring (len, args) : Fvector (len, args));
+ }
+ compose_text (data[1], data[2], components, Qnil, obj);
+ }
+ cmp_data = cmp_data->next;
+ }
+}
+
/* Decode (if ENCODEP is zero) or encode (if ENCODEP is nonzero) the
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
{
int len = to - from, len_byte = to_byte - from_byte;
int require, inserted, inserted_byte;
- int head_skip, tail_skip, total_skip;
+ int head_skip, tail_skip, total_skip = 0;
Lisp_Object saved_coding_symbol;
int multibyte = !NILP (current_buffer->enable_multibyte_characters);
int first = 1;
}
}
- coding->consumed_char = len, coding->consumed = len_byte;
-
if (encodep
? ! CODING_REQUIRE_ENCODING (coding)
: ! CODING_REQUIRE_DECODING (coding))
{
+ coding->consumed_char = len;
+ coding->consumed = len_byte;
coding->produced = len_byte;
if (multibyte
&& ! replace
new buffer. */
struct buffer *prev = current_buffer;
Lisp_Object new;
+ int count = specpdl_ptr - specpdl;
+ record_unwind_protect (code_convert_region_unwind, Qnil);
+ /* We should not call any more pre-write/post-read-conversion
+ functions while this pre-write-conversion is running. */
+ inhibit_pre_post_conversion = 1;
call2 (coding->pre_write_conversion,
make_number (from), make_number (to));
+ inhibit_pre_post_conversion = 0;
+ /* Discard the unwind protect. */
+ specpdl_ptr--;
+
if (current_buffer != prev)
{
len = ZV - BEGV;
new = Fcurrent_buffer ();
set_buffer_internal_1 (prev);
- del_range_2 (from, from_byte, to, to_byte);
+ del_range_2 (from, from_byte, to, to_byte, 0);
TEMP_SET_PT_BOTH (from, from_byte);
insert_from_buffer (XBUFFER (new), 1, len, 0);
Fkill_buffer (new);
if (replace)
deletion = make_buffer_string_both (from, from_byte, to, to_byte, 1);
- /* Try to skip the heading and tailing ASCIIs. */
- {
- 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;
- }
+ if (coding->composing != COMPOSITION_DISABLED)
+ {
+ if (encodep)
+ coding_save_composition (coding, from, to, Fcurrent_buffer ());
+ else
+ coding_allocate_composition_data (coding, from);
+ }
- 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;
- }
+ /* For conversion by CCL program and for encoding with composition
+ handling, we can't skip any character because we may convert or
+ compose even ASCII characters. */
+ if (coding->type != coding_type_ccl
+ && (!encodep || coding->cmp_data == NULL))
+ {
+ /* Try to skip the heading and tailing ASCIIs. */
+ 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
+ && (encodep || NILP (coding->post_read_conversion))
+ && ! 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;
+
+ if (coding->cmp_data)
+ coding->cmp_data->char_offset = from;
+ }
/* The code conversion routine can not preserve text properties for
now. So, we must remove all text properties in the region.
move_gap_both (from, from_byte);
inserted = inserted_byte = 0;
- src = GAP_END_ADDR, dst = GPT_ADDR;
GAP_SIZE += len_byte;
ZV -= 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;
+ if (GPT - BEG < BEG_UNCHANGED)
+ BEG_UNCHANGED = GPT - BEG;
+ if (Z - GPT < END_UNCHANGED)
+ END_UNCHANGED = Z - GPT;
for (;;)
{
int result;
- /* The buffer memory is changed from:
+ /* The buffer memory is now:
+--------+converted-text+---------+-------original-text------+---+
|<-from->|<--inserted-->|---------|<-----------len---------->|---|
|<------------------- GAP_SIZE -------------------->| */
+ src = GAP_END_ADDR - len_byte;
+ dst = GPT_ADDR + inserted_byte;
+
if (encodep)
result = encode_coding (coding, src, dst, len_byte, 0);
else
result = decode_coding (coding, src, dst, len_byte, 0);
- /* to:
+
+ /* The buffer memory is now:
+--------+-------converted-text--------+--+---original-text--+---+
|<-from->|<--inserted-->|<--produced-->|--|<-(len-consumed)->|---|
|<------------------- GAP_SIZE -------------------->| */
+
if (coding->fake_multibyte)
fake_multibyte = 1;
inserted += coding->produced_char;
inserted_byte += coding->produced;
len_byte -= coding->consumed;
+
+ if (result == CODING_FINISH_INSUFFICIENT_CMP)
+ {
+ coding_allocate_composition_data (coding, from + inserted);
+ continue;
+ }
+
src += coding->consumed;
- dst += inserted_byte;
+ dst += coding->produced;
if (result == CODING_FINISH_NORMAL)
{
if (! encodep && result == CODING_FINISH_INCONSISTENT_EOL)
{
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)
while (p < pend) if (*p++ == '\n') count++;
if (src - dst < count)
{
- /* We don't have sufficient room for putting LFs
+ /* 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
/* 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;
}
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 (src - dst > 0) *dst = 0; /* Put an anchor. */
adjust_after_replace (from, from_byte, deletion, inserted, inserted_byte);
inserted = Z - prev_Z;
+ if (!encodep && coding->cmp_data && coding->cmp_data->used)
+ coding_restore_composition (coding, Fcurrent_buffer ());
+ coding_free_composition_data (coding);
+
if (! encodep && ! NILP (coding->post_read_conversion))
{
Lisp_Object val;
+ int count = specpdl_ptr - specpdl;
if (from != PT)
TEMP_SET_PT_BOTH (from, from_byte);
prev_Z = Z;
+ record_unwind_protect (code_convert_region_unwind, Qnil);
+ /* We should not call any more pre-write/post-read-conversion
+ functions while this post-read-conversion is running. */
+ inhibit_pre_post_conversion = 1;
val = call1 (coding->post_read_conversion, make_number (inserted));
+ inhibit_pre_post_conversion = 0;
+ /* Discard the unwind protect. */
+ specpdl_ptr--;
CHECK_NUMBER (val, 0);
inserted += Z - prev_Z;
}
TEMP_SET_PT (orig_point);
}
- signal_after_change (from, to - from, inserted);
+ if (replace)
+ {
+ signal_after_change (from, to - from, inserted);
+ update_compositions (from, from + inserted, CHECK_BORDER);
+ }
{
coding->consumed = to_byte - from_byte;
int result;
saved_coding_symbol = Qnil;
- if (encodep && !NILP (coding->pre_write_conversion)
- || !encodep && !NILP (coding->post_read_conversion))
+ if ((encodep && !NILP (coding->pre_write_conversion)
+ || !encodep && !NILP (coding->post_read_conversion)))
{
/* Since we have to call Lisp functions which assume target text
- is in a buffer, after setting a temporary buffer, call
- code_convert_region. */
+ is in a buffer, after setting a temporary buffer, call
+ code_convert_region. */
int count = specpdl_ptr - specpdl;
struct buffer *prev = current_buffer;
+ int multibyte = STRING_MULTIBYTE (str);
record_unwind_protect (Fset_buffer, Fcurrent_buffer ());
+ record_unwind_protect (code_convert_region_unwind, Qnil);
+ inhibit_pre_post_conversion = 1;
+ GCPRO1 (str);
temp_output_buffer_setup (" *code-converting-work*");
set_buffer_internal (XBUFFER (Vstandard_output));
- if (encodep)
- insert_from_string (str, 0, 0, to, to_byte, 0);
- else
- {
- /* We must insert the contents of STR as is without
- unibyte<->multibyte conversion. */
- current_buffer->enable_multibyte_characters = Qnil;
- insert_from_string (str, 0, 0, to_byte, to_byte, 0);
- current_buffer->enable_multibyte_characters = Qt;
- }
+ /* We must insert the contents of STR as is without
+ unibyte<->multibyte conversion. For that, we adjust the
+ multibyteness of the working buffer to that of STR. */
+ Ferase_buffer (); /* for safety */
+ current_buffer->enable_multibyte_characters = multibyte ? Qt : Qnil;
+ insert_from_string (str, 0, 0, to, to_byte, 0);
+ UNGCPRO;
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;
+ /* Make a unibyte string if we are encoding, otherwise make a
+ multibyte string. */
+ Fset_buffer_multibyte (encodep ? Qnil : Qt);
str = make_buffer_string (BEGV, ZV, 0);
- set_buffer_internal (prev);
return unbind_to (count, str);
}
if (encodep
? ! CODING_REQUIRE_ENCODING (coding)
: ! CODING_REQUIRE_DECODING (coding))
- from = to_byte;
- else
+ return (nocopy ? str : Fcopy_sequence (str));
+
+ if (coding->composing != COMPOSITION_DISABLED)
+ {
+ if (encodep)
+ coding_save_composition (coding, from, to, str);
+ else
+ coding_allocate_composition_data (coding, from);
+ }
+
+ /* For conversion by CCL program and for encoding with composition
+ handling, we can't skip any character because we may convert or
+ compose even ASCII characters. */
+ if (coding->type != coding_type_ccl
+ && (!encodep || coding->cmp_data == NULL))
{
/* Try to skip the heading and tailing ASCIIs. */
+ int from_orig = from;
+
SHRINK_CONVERSION_REGION (&from, &to_byte, coding, XSTRING (str)->data,
encodep);
+ if (from == to_byte)
+ return (nocopy ? str : Fcopy_sequence (str));
+
+ if (coding->cmp_data)
+ coding->cmp_data->char_offset = from;
}
- 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);
buf + from, to_byte - from, len));
if (! encodep && result == CODING_FINISH_INCONSISTENT_EOL)
{
- /* We simple try to decode the whole string again but without
+ /* We simply try to decode the whole string again but without
eol-conversion this time. */
coding->eol_type = CODING_EOL_LF;
coding->symbol = saved_coding_symbol;
+ coding_free_composition_data (coding);
return code_convert_string (str, coding, encodep, nocopy);
}
str = make_multibyte_string (buf, len + chars, len + coding->produced);
}
+ if (!encodep && coding->cmp_data && coding->cmp_data->used)
+ coding_restore_composition (coding, str);
+
+ coding_free_composition_data (coding);
return str;
}
/* 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;
}
val = Fnreverse (val);
/* Then, replace the elements with subsidiary coding systems. */
- for (tmp = val; !NILP (tmp); tmp = XCONS (tmp)->cdr)
+ for (tmp = val; !NILP (tmp); tmp = XCDR (tmp))
{
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,
error ("Invalid coding system: %s", XSYMBOL (coding_system)->name->data);
coding.mode |= CODING_MODE_LAST_BLOCK;
+ string = code_convert_string (string, &coding, encodep, !NILP (nocopy));
Vlast_coding_system_used = coding.symbol;
- return code_convert_string (string, &coding, encodep, !NILP (nocopy));
+
+ return string;
}
DEFUN ("decode-coding-string", Fdecode_coding_string, Sdecode_coding_string,
}
/* Encode or decode STRING according to CODING_SYSTEM.
- Do not set Vlast_coding_system_used. */
+ Do not set Vlast_coding_system_used.
+
+ This function is called only from macros DECODE_FILE and
+ ENCODE_FILE, thus we ignore character composition. */
Lisp_Object
code_convert_string_norecord (string, coding_system, encodep)
if (setup_coding_system (Fcheck_coding_system (coding_system), &coding) < 0)
error ("Invalid coding system: %s", XSYMBOL (coding_system)->name->data);
+ coding.composing = COMPOSITION_DISABLED;
coding.mode |= CODING_MODE_LAST_BLOCK;
return code_convert_string (string, &coding, encodep, Qt);
}
s1 = (XFASTINT (code)) >> 8, s2 = (XFASTINT (code)) & 0xFF;
if (s1 == 0)
{
- if (s2 < 0xA0 || s2 > 0xDF)
- error ("Invalid Shift JIS code: %s", XFASTINT (code));
- XSETFASTINT (val, MAKE_NON_ASCII_CHAR (charset_katakana_jisx0201, s2, 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: %s", XFASTINT (code));
+ error ("Invalid Shift JIS code: %x", XFASTINT (code));
DECODE_SJIS (s1, s2, c1, c2);
XSETFASTINT (val, MAKE_NON_ASCII_CHAR (charset_jisx0208, c1, c2));
}
CHECK_NUMBER (ch, 0);
SPLIT_CHAR (XFASTINT (ch), charset, c1, c2);
- if (charset == charset_jisx0208
- && c1 > 0x20 && c1 < 0x7F && c2 > 0x20 && c2 < 0x7F)
+ 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
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
setup_coding_system (Fcheck_coding_system (coding_system), &terminal_coding);
/* We had better not send unsafe characters to terminal. */
terminal_coding.flags |= CODING_FLAG_ISO_SAFE;
-
+ /* Characer composition should be disabled. */
+ terminal_coding.composing = COMPOSITION_DISABLED;
return Qnil;
}
CHECK_SYMBOL (coding_system, 0);
setup_coding_system (Fcheck_coding_system (coding_system),
&safe_terminal_coding);
+ /* Characer composition should be disabled. */
+ safe_terminal_coding.composing = COMPOSITION_DISABLED;
return Qnil;
}
{
CHECK_SYMBOL (coding_system, 0);
setup_coding_system (Fcheck_coding_system (coding_system), &keyboard_coding);
+ /* Characer composition should be disabled. */
+ keyboard_coding.composing = COMPOSITION_DISABLED;
return Qnil;
}
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))
while (CONSP (val) && i < CODING_CATEGORY_IDX_MAX)
{
- if (! SYMBOLP (XCONS (val)->car))
+ if (! SYMBOLP (XCAR (val)))
break;
- idx = XFASTINT (Fget (XCONS (val)->car, Qcoding_category_index));
+ idx = XFASTINT (Fget (XCAR (val), Qcoding_category_index));
if (idx >= CODING_CATEGORY_IDX_MAX)
break;
coding_priorities[i++] = (1 << idx);
- val = XCONS (val)->cdr;
+ val = XCDR (val);
}
/* If coding-category-list is valid and contains all coding
categories, `i' should be CODING_CATEGORY_IDX_MAX now. If not,
for (i = 0x21 ; i < 0x7F; i++)
emacs_code_class[i] = EMACS_ascii_code;
emacs_code_class[0x7F] = EMACS_control_code;
- emacs_code_class[0x80] = EMACS_leading_code_composition;
- for (i = 0x81; i < 0xFF; i++)
+ for (i = 0x80; i < 0xFF; i++)
emacs_code_class[i] = EMACS_invalid_code;
emacs_code_class[LEADING_CODE_PRIVATE_11] = EMACS_leading_code_3;
emacs_code_class[LEADING_CODE_PRIVATE_12] = EMACS_leading_code_3;
#else
system_eol_type = CODING_EOL_LF;
#endif
+
+ inhibit_pre_post_conversion = 0;
}
#ifdef emacs
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,
See also the function `find-operation-coding-system'.");
Vnetwork_coding_system_alist = Qnil;
+ DEFVAR_LISP ("locale-coding-system", &Vlocale_coding_system,
+ "Coding system to use with system messages.");
+ Vlocale_coding_system = Qnil;
+
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 (":");
}
+char *
+emacs_strerror (error_number)
+ int error_number;
+{
+ char *str;
+
+ synchronize_system_messages_locale ();
+ str = strerror (error_number);
+
+ if (! NILP (Vlocale_coding_system))
+ {
+ Lisp_Object dec = code_convert_string_norecord (build_string (str),
+ Vlocale_coding_system,
+ 0);
+ str = (char *) XSTRING (dec)->data;
+ }
+
+ return str;
+}
+
#endif /* emacs */