/* Coding system handler (conversion, detection, and etc).
Copyright (C) 1995, 1997, 1998 Electrotechnical Laboratory, JAPAN.
Licensed to the Free Software Foundation.
+ Copyright (C) 2001 Free Software Foundation, Inc.
This file is part of GNU Emacs.
/*** 0. General comments ***/
-/*** GENERAL NOTE on CODING SYSTEM ***
+/*** GENERAL NOTE on CODING SYSTEMS ***
- Coding system is an encoding mechanism of one or more character
+ A coding system is an encoding mechanism for one or more character
sets. Here's a list of coding systems which Emacs can handle. When
we say "decode", it means converting some other coding system to
- Emacs' internal format (emacs-internal), and when we say "encode",
+ Emacs' internal format (emacs-mule), and when we say "encode",
it means converting the coding system emacs-mule to some other
coding system.
0. Emacs' internal format (emacs-mule)
- Emacs itself holds a multi-lingual character in a buffer and a string
+ Emacs itself holds a multi-lingual character in buffers and strings
in a special format. Details are described in section 2.
1. ISO2022
3. BIG5
- A coding system to encode character sets: ASCII and Big5. Widely
- used by Chinese (mainly in Taiwan and Hong Kong). Details are
+ A coding system to encode the character sets ASCII and Big5. Widely
+ used for Chinese (mainly in Taiwan and Hong Kong). Details are
described in section 4. In this file, when we write "BIG5"
(all uppercase), we mean the coding system, and when we write
"Big5" (capitalized), we mean the character set.
4. Raw text
- A coding system for a text containing random 8-bit code. Emacs does
- no code conversion on such a text except for end-of-line format.
+ A coding system for text containing random 8-bit code. Emacs does
+ no code conversion on such text except for end-of-line format.
5. Other
- If a user wants to read/write a text encoded in a coding system not
- listed above, he can supply a decoder and an encoder for it in CCL
+ If a user wants to read/write text encoded in a coding system not
+ listed above, he can supply a decoder and an encoder for it as CCL
(Code Conversion Language) programs. Emacs executes the CCL program
while reading/writing.
/*** GENERAL NOTES on END-OF-LINE FORMAT ***
- How end-of-line of a text is encoded depends on a system. For
- instance, Unix's format is just one byte of `line-feed' code,
+ How end-of-line of text is encoded depends on the operating system.
+ For instance, Unix's format is just one byte of `line-feed' code,
whereas DOS's format is two-byte sequence of `carriage-return' and
`line-feed' codes. MacOS's format is usually one byte of
`carriage-return'.
- Since text characters encoding and end-of-line encoding are
- independent, any coding system described above can take
- any format of end-of-line. So, Emacs has information of format of
- end-of-line in each coding-system. See section 6 for more details.
+ Since text character encoding and end-of-line encoding are
+ independent, any coding system described above can have any
+ end-of-line format. So Emacs has information about end-of-line
+ format in each coding-system. See section 6 for more details.
*/
These functions check if a text between SRC and SRC_END is encoded
in the coding system category XXX. Each returns an integer value in
- which appropriate flag bits for the category XXX is set. The flag
+ which appropriate flag bits for the category XXX are set. The flag
bits are defined in macros CODING_CATEGORY_MASK_XXX. Below is the
- template of these functions. If MULTIBYTEP is nonzero, 8-bit codes
+ template for these functions. If MULTIBYTEP is nonzero, 8-bit codes
of the range 0x80..0x9F are in multibyte form. */
#if 0
int
multibyte text goes to a place pointed to by DESTINATION, the length
of which should not exceed DST_BYTES.
- These functions set the information of original and decoded texts in
- the members produced, produced_char, consumed, and consumed_char of
- the structure *CODING. They also set the member result to one of
- CODING_FINISH_XXX indicating how the decoding finished.
+ These functions set the information about original and decoded texts
+ in the members `produced', `produced_char', `consumed', and
+ `consumed_char' of the structure *CODING. They also set the member
+ `result' to one of CODING_FINISH_XXX indicating how the decoding
+ finished.
- DST_BYTES zero means that source area and destination area are
+ DST_BYTES zero means that the source area and destination area are
overlapped, which means that we can produce a decoded text until it
- reaches at the head of not-yet-decoded source text.
+ reaches the head of the not-yet-decoded source text.
- Below is a template of these functions. */
+ Below is a template for these functions. */
#if 0
static void
decode_coding_XXX (coding, source, destination, src_bytes, dst_bytes)
/*** GENERAL NOTES on `encode_coding_XXX ()' functions ***
- These functions encode SRC_BYTES length text at SOURCE of Emacs'
+ These functions encode SRC_BYTES length text at SOURCE from Emacs'
internal multibyte format to CODING. The resulting unibyte text
goes to a place pointed to by DESTINATION, the length of which
should not exceed DST_BYTES.
- These functions set the information of original and encoded texts in
- the members produced, produced_char, consumed, and consumed_char of
- the structure *CODING. They also set the member result to one of
- CODING_FINISH_XXX indicating how the encoding finished.
+ These functions set the information about original and encoded texts
+ in the members `produced', `produced_char', `consumed', and
+ `consumed_char' of the structure *CODING. They also set the member
+ `result' to one of CODING_FINISH_XXX indicating how the encoding
+ finished.
- DST_BYTES zero means that source area and destination area are
- overlapped, which means that we can produce a encoded text until it
- reaches at the head of not-yet-encoded source text.
+ DST_BYTES zero means that the source area and destination area are
+ overlapped, which means that we can produce encoded text until it
+ reaches at the head of the not-yet-encoded source text.
- Below is a template of these functions. */
+ Below is a template for these functions. */
#if 0
static void
encode_coding_XXX (coding, source, destination, src_bytes, dst_bytes)
} while (0)
-/* Produce a multibyte form of characater C to `dst'. Jump to
+/* Produce a multibyte form of character C to `dst'. Jump to
`label_end_of_loop' if there's not enough space at `dst'.
- If we are now in the middle of composition sequence, the decoded
+ If we are now in the middle of a composition sequence, the decoded
character may be ALTCHAR (for the current composition). In that
case, the character goes to coding->cmp_data->data instead of
`dst'.
struct coding_system *coding_system_table[CODING_CATEGORY_IDX_MAX];
/* Table of coding category masks. Nth element is a mask for a coding
- cateogry of which priority is Nth. */
+ category of which priority is Nth. */
static
int coding_priorities[CODING_CATEGORY_IDX_MAX];
\f
/*** 2. Emacs internal format (emacs-mule) handlers ***/
-/* Emacs' internal format for encoding multiple character sets is a
- kind of multi-byte encoding, i.e. characters are encoded by
- variable-length sequences of one-byte codes.
+/* Emacs' internal format for representation of multiple character
+ sets is a kind of multi-byte encoding, i.e. characters are
+ represented by variable-length sequences of one-byte codes.
ASCII characters and control characters (e.g. `tab', `newline') are
represented by one-byte sequences which are their ASCII codes, in
The other characters are represented by a sequence of `base
leading-code', optional `extended leading-code', and one or two
`position-code's. The length of the sequence is determined by the
- base leading-code. Leading-code takes the range 0x80 through 0x9F,
+ base leading-code. Leading-code takes the range 0x81 through 0x9D,
whereas extended leading-code and position-code take the range 0xA0
through 0xFF. See `charset.h' for more details about leading-code
and position-code.
ascii 0x00..0x7F
eight-bit-control LEADING_CODE_8_BIT_CONTROL + 0xA0..0xBF
eight-bit-graphic 0xA0..0xBF
- ELSE 0x81..0x9F + [0xA0..0xFF]+
+ ELSE 0x81..0x9D + [0xA0..0xFF]+
---------------------------------------------
+ As this is the internal character representation, the format is
+ usually not used externally (i.e. in a file or in a data sent to a
+ process). But, it is possible to have a text externally in this
+ format (i.e. by encoding by the coding system `emacs-mule').
+
+ In that case, a sequence of one-byte codes has a slightly different
+ form.
+
+ Firstly, all characters in eight-bit-control are represented by
+ one-byte sequences which are their 8-bit code.
+
+ Next, character composition data are represented by the byte
+ sequence of the form: 0x80 METHOD BYTES CHARS COMPONENT ...,
+ where,
+ METHOD is 0xF0 plus one of composition method (enum
+ composition_method),
+
+ BYTES is 0xA0 plus the byte length of these composition data,
+
+ CHARS is 0xA0 plus the number of characters composed by these
+ data,
+
+ COMPONENTs are characters of multibyte form or composition
+ rules encoded by two-byte of ASCII codes.
+
+ In addition, for backward compatibility, the following formats are
+ also recognized as composition data on decoding.
+
+ 0x80 MSEQ ...
+ 0x80 0xFF MSEQ RULE MSEQ RULE ... MSEQ
+
+ Here,
+ MSEQ is a multibyte form but in these special format:
+ ASCII: 0xA0 ASCII_CODE+0x80,
+ other: LEADING_CODE+0x20 FOLLOWING-BYTE ...,
+ RULE is a one byte code of the range 0xA0..0xF0 that
+ represents a composition rule.
*/
enum emacs_code_class_type emacs_code_class[256];
}
+/* 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)
+
+
+/* Get one byte from a data pointed by SRC and increment SRC. If SRC
+ is not less than SRC_END, return -1 without incrementing Src. */
+
+#define SAFE_ONE_MORE_BYTE() (src >= src_end ? -1 : *src++)
+
+
+/* Decode a character represented as a component of composition
+ sequence of Emacs 20 style at SRC. Set C to that character, store
+ its multibyte form sequence at P, and set P to the end of that
+ sequence. If no valid character is found, set C to -1. */
+
+#define DECODE_EMACS_MULE_COMPOSITION_CHAR(c, p) \
+ do { \
+ int bytes; \
+ \
+ c = SAFE_ONE_MORE_BYTE (); \
+ if (c < 0) \
+ break; \
+ if (CHAR_HEAD_P (c)) \
+ c = -1; \
+ else if (c == 0xA0) \
+ { \
+ c = SAFE_ONE_MORE_BYTE (); \
+ if (c < 0xA0) \
+ c = -1; \
+ else \
+ { \
+ c -= 0xA0; \
+ *p++ = c; \
+ } \
+ } \
+ else if (BASE_LEADING_CODE_P (c - 0x20)) \
+ { \
+ unsigned char *p0 = p; \
+ \
+ c -= 0x20; \
+ *p++ = c; \
+ bytes = BYTES_BY_CHAR_HEAD (c); \
+ while (--bytes) \
+ { \
+ c = SAFE_ONE_MORE_BYTE (); \
+ if (c < 0) \
+ break; \
+ *p++ = c; \
+ } \
+ if (UNIBYTE_STR_AS_MULTIBYTE_P (p0, p - p0, bytes)) \
+ c = STRING_CHAR (p0, bytes); \
+ else \
+ c = -1; \
+ } \
+ else \
+ c = -1; \
+ } while (0)
+
+
+/* Decode a composition rule represented as a component of composition
+ sequence of Emacs 20 style at SRC. Set C to the rule. If not
+ valid rule is found, set C to -1. */
+
+#define DECODE_EMACS_MULE_COMPOSITION_RULE(c) \
+ do { \
+ c = SAFE_ONE_MORE_BYTE (); \
+ c -= 0xA0; \
+ if (c < 0 || c >= 81) \
+ c = -1; \
+ else \
+ { \
+ gref = c / 9, nref = c % 9; \
+ c = COMPOSITION_ENCODE_RULE (gref, nref); \
+ } \
+ } while (0)
+
+
+/* Decode composition sequence encoded by `emacs-mule' at the source
+ pointed by SRC. SRC_END is the end of source. Store information
+ of the composition in CODING->cmp_data.
+
+ For backward compatibility, decode also a composition sequence of
+ Emacs 20 style. In that case, the composition sequence contains
+ characters that should be extracted into a buffer or string. Store
+ those characters at *DESTINATION in multibyte form.
+
+ If we encounter an invalid byte sequence, return 0.
+ If we encounter an insufficient source or destination, or
+ insufficient space in CODING->cmp_data, return 1.
+ Otherwise, return consumed bytes in the source.
+
+*/
+static INLINE int
+decode_composition_emacs_mule (coding, src, src_end,
+ destination, dst_end, dst_bytes)
+ struct coding_system *coding;
+ unsigned char *src, *src_end, **destination, *dst_end;
+ int dst_bytes;
+{
+ unsigned char *dst = *destination;
+ int method, data_len, nchars;
+ unsigned char *src_base = src++;
+ /* Store components of composition. */
+ int component[COMPOSITION_DATA_MAX_BUNCH_LENGTH];
+ int ncomponent;
+ /* Store multibyte form of characters to be composed. This is for
+ Emacs 20 style composition sequence. */
+ unsigned char buf[MAX_COMPOSITION_COMPONENTS * MAX_MULTIBYTE_LENGTH];
+ unsigned char *bufp = buf;
+ int c, i, gref, nref;
+
+ if (coding->cmp_data->used + COMPOSITION_DATA_MAX_BUNCH_LENGTH
+ >= COMPOSITION_DATA_SIZE)
+ {
+ coding->result = CODING_FINISH_INSUFFICIENT_CMP;
+ return -1;
+ }
+
+ ONE_MORE_BYTE (c);
+ if (c - 0xF0 >= COMPOSITION_RELATIVE
+ && c - 0xF0 <= COMPOSITION_WITH_RULE_ALTCHARS)
+ {
+ int with_rule;
+
+ method = c - 0xF0;
+ with_rule = (method == COMPOSITION_WITH_RULE
+ || method == COMPOSITION_WITH_RULE_ALTCHARS);
+ ONE_MORE_BYTE (c);
+ data_len = c - 0xA0;
+ if (data_len < 4
+ || src_base + data_len > src_end)
+ return 0;
+ ONE_MORE_BYTE (c);
+ nchars = c - 0xA0;
+ if (c < 1)
+ return 0;
+ for (ncomponent = 0; src < src_base + data_len; ncomponent++)
+ {
+ if (ncomponent % 2 && with_rule)
+ {
+ ONE_MORE_BYTE (gref);
+ gref -= 32;
+ ONE_MORE_BYTE (nref);
+ nref -= 32;
+ c = COMPOSITION_ENCODE_RULE (gref, nref);
+ }
+ else
+ {
+ int bytes;
+ if (UNIBYTE_STR_AS_MULTIBYTE_P (src, src_end - src, bytes))
+ c = STRING_CHAR (src, bytes);
+ else
+ c = *src, bytes = 1;
+ src += bytes;
+ }
+ component[ncomponent] = c;
+ }
+ }
+ else
+ {
+ /* This may be an old Emacs 20 style format. See the comment at
+ the section 2 of this file. */
+ while (src < src_end && !CHAR_HEAD_P (*src)) src++;
+ if (src == src_end
+ && !(coding->mode & CODING_MODE_LAST_BLOCK))
+ goto label_end_of_loop;
+
+ src_end = src;
+ src = src_base + 1;
+ if (c < 0xC0)
+ {
+ method = COMPOSITION_RELATIVE;
+ for (ncomponent = 0; ncomponent < MAX_COMPOSITION_COMPONENTS;)
+ {
+ DECODE_EMACS_MULE_COMPOSITION_CHAR (c, bufp);
+ if (c < 0)
+ break;
+ component[ncomponent++] = c;
+ }
+ if (ncomponent < 2)
+ return 0;
+ nchars = ncomponent;
+ }
+ else if (c == 0xFF)
+ {
+ method = COMPOSITION_WITH_RULE;
+ src++;
+ DECODE_EMACS_MULE_COMPOSITION_CHAR (c, bufp);
+ if (c < 0)
+ return 0;
+ component[0] = c;
+ for (ncomponent = 1;
+ ncomponent < MAX_COMPOSITION_COMPONENTS * 2 - 1;)
+ {
+ DECODE_EMACS_MULE_COMPOSITION_RULE (c);
+ if (c < 0)
+ break;
+ component[ncomponent++] = c;
+ DECODE_EMACS_MULE_COMPOSITION_CHAR (c, bufp);
+ if (c < 0)
+ break;
+ component[ncomponent++] = c;
+ }
+ if (ncomponent < 3)
+ return 0;
+ nchars = (ncomponent + 1) / 2;
+ }
+ else
+ return 0;
+ }
+
+ if (buf == bufp || dst + (bufp - buf) <= (dst_bytes ? dst_end : src))
+ {
+ CODING_ADD_COMPOSITION_START (coding, coding->produced_char, method);
+ for (i = 0; i < ncomponent; i++)
+ CODING_ADD_COMPOSITION_COMPONENT (coding, component[i]);
+ CODING_ADD_COMPOSITION_END (coding, coding->produced_char + nchars);
+ if (buf < bufp)
+ {
+ unsigned char *p = buf;
+ EMIT_BYTES (p, bufp);
+ *destination += bufp - buf;
+ coding->produced_char += nchars;
+ }
+ return (src - src_base);
+ }
+ label_end_of_loop:
+ return -1;
+}
+
/* See the above "GENERAL NOTES on `decode_coding_XXX ()' functions". */
static void
coding->produced_char++;
continue;
}
+ else if (*src == 0x80)
+ {
+ /* Start of composition data. */
+ int consumed = decode_composition_emacs_mule (coding, src, src_end,
+ &dst, dst_end,
+ dst_bytes);
+ if (consumed < 0)
+ goto label_end_of_loop;
+ else if (consumed > 0)
+ {
+ src += consumed;
+ continue;
+ }
+ bytes = CHAR_STRING (*src, tmp);
+ p = tmp;
+ src++;
+ }
else if (UNIBYTE_STR_AS_MULTIBYTE_P (src, src_end - src, bytes))
{
p = src;
coding->produced = dst - destination;
}
-#define encode_coding_emacs_mule(coding, source, destination, src_bytes, dst_bytes) \
- encode_eol (coding, source, destination, src_bytes, dst_bytes)
+/* Encode composition data stored at DATA into a special byte sequence
+ starting by 0x80. Update CODING->cmp_data_start and maybe
+ CODING->cmp_data for the next call. */
+
+#define ENCODE_COMPOSITION_EMACS_MULE(coding, data) \
+ do { \
+ unsigned char buf[1024], *p0 = buf, *p; \
+ int len = data[0]; \
+ int i; \
+ \
+ buf[0] = 0x80; \
+ buf[1] = 0xF0 + data[3]; /* METHOD */ \
+ buf[3] = 0xA0 + (data[2] - data[1]); /* COMPOSED-CHARS */ \
+ p = buf + 4; \
+ if (data[3] == COMPOSITION_WITH_RULE \
+ || data[3] == COMPOSITION_WITH_RULE_ALTCHARS) \
+ { \
+ p += CHAR_STRING (data[4], p); \
+ for (i = 5; i < len; i += 2) \
+ { \
+ int gref, nref; \
+ COMPOSITION_DECODE_RULE (data[i], gref, nref); \
+ *p++ = 0x20 + gref; \
+ *p++ = 0x20 + nref; \
+ p += CHAR_STRING (data[i + 1], p); \
+ } \
+ } \
+ else \
+ { \
+ for (i = 4; i < len; i++) \
+ p += CHAR_STRING (data[i], p); \
+ } \
+ buf[2] = 0xA0 + (p - buf); /* COMPONENTS-BYTES */ \
+ \
+ if (dst + (p - buf) + 4 > (dst_bytes ? dst_end : src)) \
+ { \
+ coding->result = CODING_FINISH_INSUFFICIENT_DST; \
+ goto label_end_of_loop; \
+ } \
+ while (p0 < p) \
+ *dst++ = *p0++; \
+ coding->cmp_data_start += data[0]; \
+ 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)
+
+
+static void encode_eol P_ ((struct coding_system *, unsigned char *,
+ unsigned char *, int, int));
+
+static void
+encode_coding_emacs_mule (coding, source, destination, src_bytes, dst_bytes)
+ struct coding_system *coding;
+ unsigned char *source, *destination;
+ int src_bytes, dst_bytes;
+{
+ unsigned char *src = source;
+ unsigned char *src_end = source + src_bytes;
+ unsigned char *dst = destination;
+ unsigned char *dst_end = destination + dst_bytes;
+ unsigned char *src_base;
+ int c;
+ int char_offset;
+ int *data;
+
+ Lisp_Object translation_table;
+
+ translation_table = Qnil;
+
+ /* Optimization for the case that there's no composition. */
+ if (!coding->cmp_data || coding->cmp_data->used == 0)
+ {
+ encode_eol (coding, source, destination, src_bytes, dst_bytes);
+ return;
+ }
+
+ char_offset = coding->cmp_data->char_offset;
+ data = coding->cmp_data->data + coding->cmp_data_start;
+ while (1)
+ {
+ src_base = src;
+
+ /* If SRC starts a composition, encode the information about the
+ composition in advance. */
+ if (coding->cmp_data_start < coding->cmp_data->used
+ && char_offset + coding->consumed_char == data[1])
+ {
+ ENCODE_COMPOSITION_EMACS_MULE (coding, data);
+ char_offset = coding->cmp_data->char_offset;
+ data = coding->cmp_data->data + coding->cmp_data_start;
+ }
+
+ ONE_MORE_CHAR (c);
+ if (c == '\n' && (coding->eol_type == CODING_EOL_CRLF
+ || coding->eol_type == CODING_EOL_CR))
+ {
+ if (coding->eol_type == CODING_EOL_CRLF)
+ EMIT_TWO_BYTES ('\r', c);
+ else
+ EMIT_ONE_BYTE ('\r');
+ }
+ else if (SINGLE_BYTE_CHAR_P (c))
+ EMIT_ONE_BYTE (c);
+ else
+ EMIT_BYTES (src_base, src);
+ coding->consumed_char++;
+ }
+ label_end_of_loop:
+ coding->consumed = src_base - source;
+ coding->produced = coding->produced_char = dst - destination;
+ return;
+}
\f
/*** 3. ISO2022 handlers ***/
/* The following note describes the coding system ISO2022 briefly.
Since the intention of this note is to help understand the
- functions in this file, some parts are NOT ACCURATE or OVERLY
+ functions in this file, some parts are NOT ACCURATE or are OVERLY
SIMPLIFIED. For thorough understanding, please refer to the
- original document of ISO2022.
+ original document of ISO2022. This is equivalent to the standard
+ ECMA-35, obtainable from <URL:http://www.ecma.ch/> (*).
ISO2022 provides many mechanisms to encode several character sets
- in 7-bit and 8-bit environments. For 7-bite environments, all text
+ in 7-bit and 8-bit environments. For 7-bit 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).
+ several types of gateway, some of which strip off the MSB (Most
+ Significant Bit).
- There are two kinds of character sets: control character set and
- graphic character set. The former contains control characters such
+ There are two kinds of character sets: control character sets and
+ graphic character sets. The former contain control characters such
as `newline' and `escape' to provide control functions (control
functions are also provided by escape sequences). The latter
- contains graphic characters such as 'A' and '-'. Emacs recognizes
+ contain 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
- DIMENSION2_CHARS96
In addition, each character set is assigned an identification tag,
- unique for each set, called "final character" (denoted as <F>
+ unique for each set, called the "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
- Here are examples of graphic character set [NAME(<F>)]:
+ Here are examples of graphic character sets [NAME(<F>)]:
o DIMENSION1_CHARS94 -- ASCII('B'), right-half-of-JISX0201('I'), ...
o DIMENSION1_CHARS96 -- right-half-of-ISO8859-1('A'), ...
o DIMENSION2_CHARS94 -- GB2312('A'), JISX0208('B'), ...
Note (**): If <F> is '@', 'A', or 'B', the intermediate character
'(' 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
+ Now you may notice that there are a lot of ways of encoding the
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
+ 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
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.
+ the use of them with these meanings is restricted to Emacs only.
- (*) This form is used only in Emacs 20.5 and the older versions,
+ (*) This form is used only in Emacs 20.5 and older versions,
but the newer versions can safely decode it.
- (**) This form is used only in Emacs 21.1 and the newer versions,
+ (**) This form is used only in Emacs 21.1 and newer versions,
and the older versions can't decode it.
- Here's a list of examples usages of these composition escape
+ Here's a list of example usages of these composition escape
sequences (categorized by `enum composition_method').
COMPOSITION_RELATIVE:
ESC 0 CHAR [ CHAR ] ESC 1
- COMPOSITOIN_WITH_RULE:
+ COMPOSITION_WITH_RULE:
ESC 2 CHAR [ RULE CHAR ] ESC 1
COMPOSITION_WITH_ALTCHARS:
ESC 3 ALTCHAR [ ALTCHAR ] ESC 0 CHAR [ CHAR ] ESC 1
(CODING_SPEC_ISO_INITIAL_DESIGNATION (coding_system_table[idx], 1) >= 0)
/* See the above "GENERAL NOTES on `detect_coding_XXX ()' functions".
- Check if a text is encoded in ISO2022. If it is, returns an
+ Check if a text is encoded in ISO2022. If it is, return an
integer in which appropriate flag bits any of:
CODING_CATEGORY_MASK_ISO_7
CODING_CATEGORY_MASK_ISO_7_TIGHT
int mask = CODING_CATEGORY_MASK_ISO;
int mask_found = 0;
int reg[4], shift_out = 0, single_shifting = 0;
- int c, c1, i, charset;
+ int c, c1, charset;
/* Dummy for ONE_MORE_BYTE. */
struct coding_system dummy_coding;
struct coding_system *coding = &dummy_coding;
coding->cmp_data_start = 0;
}
-/* 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. */
+/* Handle composition start sequence ESC 0, ESC 2, ESC 3, or ESC 4.
+ ESC 0 : relative composition : ESC 0 CHAR ... ESC 1
+ ESC 2 : rulebase composition : ESC 2 CHAR RULE CHAR RULE ... CHAR ESC 1
+ ESC 3 : altchar composition : ESC 3 ALT ... ESC 0 CHAR ... ESC 1
+ ESC 4 : alt&rule composition : ESC 4 ALT RULE .. ALT ESC 0 CHAR ... ESC 1
+ */
#define DECODE_COMPOSITION_START(c1) \
do { \
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 \
+ coding->cmp_data in the caller, then start the decoding \
loop again. We can't allocate memory here directly because \
it may cause buffer/string relocation. */ \
if (!coding->cmp_data \
} \
} while (0)
-/* Handle compositoin end sequence ESC 1. */
+/* Handle composition end sequence ESC 1. */
#define DECODE_COMPOSITION_END(c1) \
do { \
goto label_invalid_code;
/* For the moment, nested direction is not supported.
So, `coding->mode & CODING_MODE_DIRECTION' zero means
- left-to-right, and nozero means right-to-left. */
+ left-to-right, and nonzero means right-to-left. */
ONE_MORE_BYTE (c1);
switch (c1)
{
/*
It is not enough to say just "ISO2022" on encoding, we have to
- specify more details. In Emacs, each coding system of ISO2022
+ specify more details. In Emacs, each ISO2022 coding system
variant has the following specifications:
- 1. Initial designation to G0 thru G3.
+ 1. Initial designation to G0 through G3.
2. Allows short-form designation?
3. ASCII should be designated to G0 before control characters?
4. ASCII should be designated to G0 at end of line?
/* 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
+ What follows in SRC is the composition's base
text. */
ENCODE_COMPOSITION_FAKE_START (coding);
else
\f
/*** 4. SJIS and BIG5 handlers ***/
-/* Although SJIS and BIG5 are not ISO's coding system, they are used
+/* Although SJIS and BIG5 are not ISO coding systems, they are used
quite widely. So, for the moment, Emacs supports them in the bare
C code. But, in the future, they may be supported only by CCL. */
as is. A character of charset katakana-jisx0201 is encoded by
"position-code + 0x80". A character of charset japanese-jisx0208
is encoded in 2-byte but two position-codes are divided and shifted
- so that it fit in the range below.
+ so that it fits in the range below.
--- CODE RANGE of SJIS ---
(character set) (range)
ASCII 0x00 .. 0x7F
- KATAKANA-JISX0201 0xA0 .. 0xDF
+ KATAKANA-JISX0201 0xA1 .. 0xDF
JISX0208 (1st byte) 0x81 .. 0x9F and 0xE0 .. 0xEF
(2nd byte) 0x40 .. 0x7E and 0x80 .. 0xFC
-------------------------------
/* BIG5 is a coding system encoding two character sets: ASCII and
Big5. An ASCII character is encoded as is. Big5 is a two-byte
- character set and is encoded in two-byte.
+ character set and is encoded in two bytes.
--- CODE RANGE of BIG5 ---
(character set) (range)
while (1)
{
ONE_MORE_BYTE_CHECK_MULTIBYTE (c, multibytep);
- if (c >= 0x81)
+ if (c < 0x80)
+ continue;
+ if (c == 0x80 || c == 0xA0 || c > 0xEF)
+ return 0;
+ if (c <= 0x9F || c >= 0xE0)
{
- if (c <= 0x9F || (c >= 0xE0 && c <= 0xEF))
- {
- ONE_MORE_BYTE_CHECK_MULTIBYTE (c, multibytep);
- if (c < 0x40 || c == 0x7F || c > 0xFC)
- return 0;
- }
- else if (c > 0xDF)
+ ONE_MORE_BYTE_CHECK_MULTIBYTE (c, multibytep);
+ if (c < 0x40 || c == 0x7F || c > 0xFC)
return 0;
}
}
while (1)
{
ONE_MORE_BYTE_CHECK_MULTIBYTE (c, multibytep);
- if (c >= 0xA1)
- {
- ONE_MORE_BYTE_CHECK_MULTIBYTE (c, multibytep);
- if (c < 0x40 || (c >= 0x7F && c <= 0xA0))
- return 0;
- }
+ if (c < 0x80)
+ continue;
+ if (c < 0xA1 || c > 0xFE)
+ return 0;
+ ONE_MORE_BYTE_CHECK_MULTIBYTE (c, multibytep);
+ if (c < 0x40 || (c > 0x7F && c < 0xA1) || c > 0xFE)
+ return 0;
}
label_end_of_loop:
return CODING_CATEGORY_MASK_BIG5;
{
if (sjis_p)
{
- if (c1 >= 0xF0)
+ if (c1 == 0x80 || c1 == 0xA0 || c1 > 0xEF)
goto label_invalid_code;
- if (c1 < 0xA0 || c1 >= 0xE0)
+ if (c1 <= 0x9F || c1 >= 0xE0)
{
/* SJIS -> JISX0208 */
ONE_MORE_BYTE (c2);
else
{
/* BIG5 -> Big5 */
- if (c1 < 0xA1 || c1 > 0xFE)
+ if (c1 < 0xA0 || c1 > 0xFE)
goto label_invalid_code;
ONE_MORE_BYTE (c2);
if (c2 < 0x40 || (c2 > 0x7E && c2 < 0xA1) || c2 > 0xFE)
/* See "GENERAL NOTES about `encode_coding_XXX ()' functions". Encode
format of end-of-line according to `coding->eol_type'. It also
- convert multibyte form 8-bit characers to unibyte if
+ convert multibyte form 8-bit characters to unibyte if
CODING->src_multibyte is nonzero. If `coding->mode &
CODING_MODE_SELECTIVE_DISPLAY' is nonzero, code '\r' in source text
also means end-of-line. */
\f
/*** 7. C library functions ***/
-/* In Emacs Lisp, coding system is represented by a Lisp symbol which
+/* In Emacs Lisp, a coding system is represented by a Lisp symbol which
has a property `coding-system'. The value of this property is a
- vector of length 5 (called as coding-vector). Among elements of
+ vector of length 5 (called the coding-vector). Among elements of
this vector, the first (element[0]) and the fifth (element[4])
carry important information for decoding/encoding. Before
decoding/encoding, this information should be set in fields of a
structure of type `coding_system'.
- A value of property `coding-system' can be a symbol of another
+ The value of the property `coding-system' can be a symbol of another
subsidiary coding-system. In that case, Emacs gets coding-vector
from that symbol.
If `coding->type' takes the other value, element[4] is ignored.
- Emacs Lisp's coding system also carries information about format of
+ Emacs Lisp's coding systems also carry information about format of
end-of-line in a value of property `eol-type'. If the value is
integer, 0 means CODING_EOL_LF, 1 means CODING_EOL_CRLF, and 2
means CODING_EOL_CR. If it is not integer, it should be a vector
of subsidiary coding systems of which property `eol-type' has one
- of above values.
+ of the above values.
*/
{
Lisp_Object coding_spec, coding_type, eol_type, plist;
Lisp_Object val;
- int i;
+
+ /* At first, zero clear all members. */
+ bzero (coding, sizeof (struct coding_system));
/* Initialize some fields required for all kinds of coding systems. */
coding->symbol = coding_system;
- coding->common_flags = 0;
- coding->mode = 0;
coding->heading_ascii = -1;
coding->post_read_conversion = coding->pre_write_conversion = Qnil;
coding->composing = COMPOSITION_DISABLED;
`translation-table-for-decode', `translation-table-for-encode'. */
plist = XVECTOR (coding_spec)->contents[3];
/* Pre & post conversion functions should be disabled if
- inhibit_eol_conversion is nozero. This is the case that a code
+ inhibit_eol_conversion is nonzero. This is the case that a code
conversion function is called while those functions are running. */
if (! inhibit_pre_post_conversion)
{
{
case 0:
coding->type = coding_type_emacs_mule;
+ coding->common_flags
+ |= CODING_REQUIRE_DECODING_MASK | CODING_REQUIRE_ENCODING_MASK;
+ coding->composing = COMPOSITION_NO;
if (!NILP (coding->post_read_conversion))
coding->common_flags |= CODING_REQUIRE_DECODING_MASK;
if (!NILP (coding->pre_write_conversion))
if (reg_bits)
for (charset = 0; charset <= MAX_CHARSET; charset++)
{
- if (CHARSET_VALID_P (charset)
+ if (CHARSET_DEFINED_P (charset)
&& (CODING_SPEC_ISO_REQUESTED_DESIGNATION (coding, charset)
== CODING_SPEC_ISO_NO_REQUESTED_DESIGNATION))
{
}
coding->common_flags |= CODING_REQUIRE_FLUSHING_MASK;
coding->spec.ccl.cr_carryover = 0;
+ coding->spec.ccl.eight_bit_carryover[0] = 0;
break;
case 5:
o coding-category-iso-7-else
The category for a coding system which has the same code range
- as ISO2022 of 7-bit environemnt but uses locking shift or
+ as ISO2022 of 7-bit environment but uses locking shift or
single shift functions. Assigned the coding-system (Lisp
symbol) `iso-2022-7bit-lock' by default.
o coding-category-iso-8-else
The category for a coding system which has the same code range
- as ISO2022 of 8-bit environemnt but uses locking shift or
+ as ISO2022 of 8-bit environment but uses locking shift or
single shift functions. Assigned the coding-system (Lisp
symbol) `iso-2022-8bit-ss2' by default.
`no-conversion' by default.
Each of them is a Lisp symbol and the value is an actual
- `coding-system's (this is also a Lisp symbol) assigned by a user.
+ `coding-system' (this is also a Lisp symbol) assigned by a user.
What Emacs does actually is to detect a category of coding system.
Then, it uses a `coding-system' assigned to it. If Emacs can't
- decide only one possible category, it selects a category of the
+ decide a single possible category, it selects a category of the
highest priority. Priorities of categories are also specified by a
user in a Lisp variable `coding-category-list'.
register unsigned char c;
unsigned char *src = source, *src_end = source + src_bytes;
unsigned int mask, utf16_examined_p, iso2022_examined_p;
- int i, idx;
+ int i;
/* At first, skip all ASCII characters and control characters except
for three ISO2022 specific control characters. */
int try;
if (multibytep && c == LEADING_CODE_8_BIT_CONTROL)
- c = *src++ - 0x20;
+ c = src[1] - 0x20;
if (c < 0xA0)
{
int src_bytes;
{
unsigned int idx;
- int skip, mask, i;
+ int skip, mask;
Lisp_Object val;
val = Vcoding_category_list;
- mask = detect_coding_mask (src, src_bytes, coding_priorities, &skip, 0);
+ mask = detect_coding_mask (src, src_bytes, coding_priorities, &skip,
+ coding->src_multibyte);
coding->heading_ascii = skip;
if (!mask) return;
if (! mask)
idx = CODING_CATEGORY_IDX_RAW_TEXT;
- val = XSYMBOL (XVECTOR (Vcoding_category_table)->contents[idx])->value;
+ val = SYMBOL_VALUE (XVECTOR (Vcoding_category_table)->contents[idx]);
if (coding->eol_type != CODING_EOL_UNDECIDED)
{
static int
detect_eol_type_in_2_octet_form (source, src_bytes, skip, big_endian_p)
unsigned char *source;
- int src_bytes, *skip;
+ int src_bytes, *skip, big_endian_p;
{
unsigned char *src = source, *src_end = src + src_bytes;
unsigned int c1, c2;
{
struct ccl_program *ccl
= encodep ? &coding->spec.ccl.encoder : &coding->spec.ccl.decoder;
- int result;
+ unsigned char *dst = destination;
+ ccl->suppress_error = coding->suppress_error;
ccl->last_block = coding->mode & CODING_MODE_LAST_BLOCK;
if (encodep)
- ccl->eol_type = coding->eol_type;
+ {
+ /* On encoding, EOL format is converted within ccl_driver. For
+ that, setup proper information in the structure CCL. */
+ ccl->eol_type = coding->eol_type;
+ if (ccl->eol_type ==CODING_EOL_UNDECIDED)
+ ccl->eol_type = CODING_EOL_LF;
+ ccl->cr_consumed = coding->spec.ccl.cr_carryover;
+ }
ccl->multibyte = coding->src_multibyte;
- coding->produced = ccl_driver (ccl, source, destination,
- src_bytes, dst_bytes, &(coding->consumed));
+ if (coding->spec.ccl.eight_bit_carryover[0] != 0)
+ {
+ /* Move carryover bytes to DESTINATION. */
+ unsigned char *p = coding->spec.ccl.eight_bit_carryover;
+ while (*p)
+ *dst++ = *p++;
+ coding->spec.ccl.eight_bit_carryover[0] = 0;
+ if (dst_bytes)
+ dst_bytes -= dst - destination;
+ }
+
+ coding->produced = (ccl_driver (ccl, source, dst, src_bytes, dst_bytes,
+ &(coding->consumed))
+ + dst - destination);
+
if (encodep)
- coding->produced_char = coding->produced;
+ {
+ coding->produced_char = coding->produced;
+ coding->spec.ccl.cr_carryover = ccl->cr_consumed;
+ }
+ else if (!ccl->eight_bit_control)
+ {
+ /* The produced bytes forms a valid multibyte sequence. */
+ coding->produced_char
+ = multibyte_chars_in_text (destination, coding->produced);
+ coding->spec.ccl.eight_bit_carryover[0] = 0;
+ }
else
{
+ /* On decoding, the destination should always multibyte. But,
+ CCL program might have been generated an invalid multibyte
+ sequence. Here we make such a sequence valid as
+ multibyte. */
int bytes
= dst_bytes ? dst_bytes : source + coding->consumed - destination;
+
+ if ((coding->consumed < src_bytes
+ || !ccl->last_block)
+ && coding->produced >= 1
+ && destination[coding->produced - 1] >= 0x80)
+ {
+ /* We should not convert the tailing 8-bit codes to
+ multibyte form even if they doesn't form a valid
+ multibyte sequence. They may form a valid sequence in
+ the next call. */
+ int carryover = 0;
+
+ if (destination[coding->produced - 1] < 0xA0)
+ carryover = 1;
+ else if (coding->produced >= 2)
+ {
+ if (destination[coding->produced - 2] >= 0x80)
+ {
+ if (destination[coding->produced - 2] < 0xA0)
+ carryover = 2;
+ else if (coding->produced >= 3
+ && destination[coding->produced - 3] >= 0x80
+ && destination[coding->produced - 3] < 0xA0)
+ carryover = 3;
+ }
+ }
+ if (carryover > 0)
+ {
+ BCOPY_SHORT (destination + coding->produced - carryover,
+ coding->spec.ccl.eight_bit_carryover,
+ carryover);
+ coding->spec.ccl.eight_bit_carryover[carryover] = 0;
+ coding->produced -= carryover;
+ }
+ }
coding->produced = str_as_multibyte (destination, bytes,
coding->produced,
&(coding->produced_char));
if (coding->eol_type == CODING_EOL_UNDECIDED
&& coding->type != coding_type_ccl)
- detect_eol (coding, source, src_bytes);
+ {
+ detect_eol (coding, source, src_bytes);
+ /* We had better recover the original eol format if we
+ encounter an inconsistent eol format while decoding. */
+ coding->mode |= CODING_MODE_INHIBIT_INCONSISTENT_EOL;
+ }
coding->produced = coding->produced_char = 0;
coding->consumed = coding->consumed_char = 0;
&& coding->result == CODING_FINISH_INSUFFICIENT_SRC)
{
unsigned char *src = source + coding->consumed;
- unsigned char *src_end = src + src_bytes;
unsigned char *dst = destination + coding->produced;
if (coding->type == coding_type_iso2022)
{
int len = src_bytes - coding->consumed;
- BCOPY_SHORT (source + coding->consumed, dst, len);
+ BCOPY_SHORT (src, dst, len);
if (coding->src_multibyte)
len = str_as_unibyte (dst, len);
dst += len;
case CODING_CATEGORY_IDX_ISO_7:
case CODING_CATEGORY_IDX_ISO_7_TIGHT:
{
- /* We can skip all charactes at the tail except for 8-bit
+ /* We can skip all characters at the tail except for 8-bit
codes and ESC and the following 2-byte at the tail. */
unsigned char *eight_bit = NULL;
if (!NILP (CHAR_TABLE_REF (translation_table, i)))
break;
if (i < 128)
- /* Some ASCII character should be tranlsated. We give up
+ /* Some ASCII character should be translated. We give up
shrinking. */
return;
}
}
/* Reflect the saved information about compositions to OBJ.
- CODING->cmp_data points to a memory block for the informaiton. OBJ
+ CODING->cmp_data points to a memory block for the information. OBJ
is a buffer or a string, defaults to the current buffer. */
void
replace_range (insdel.c) to know what we are doing.
If REPLACE is zero, it is assumed that the source text is unibyte.
- Otherwize, it is assumed that the source text is multibyte. */
+ Otherwise, it is assumed that the source text is multibyte. */
int
code_convert_region (from, from_byte, to, to_byte, coding, encodep, replace)
int prev_Z;
int multibyte_p = !NILP (current_buffer->enable_multibyte_characters);
- coding->src_multibyte = replace && multibyte_p;
- coding->dst_multibyte = multibyte_p;
-
deletion = Qnil;
- saved_coding_symbol = Qnil;
+ saved_coding_symbol = coding->symbol;
if (from < PT && PT < to)
{
encodings again in vain. */
coding->type = coding_type_emacs_mule;
coding->category_idx = CODING_CATEGORY_IDX_EMACS_MULE;
+ /* As emacs-mule decoder will handle composition, we
+ need this setting to allocate coding->cmp_data
+ later. */
+ coding->composing = COMPOSITION_NO;
}
}
if (coding->eol_type == CODING_EOL_UNDECIDED
&& coding->type != coding_type_ccl)
{
- saved_coding_symbol = coding->symbol;
detect_eol (coding, BYTE_POS_ADDR (from_byte), len_byte);
if (coding->eol_type == CODING_EOL_UNDECIDED)
coding->eol_type = CODING_EOL_LF;
/* We had better recover the original eol format if we
- encounter an inconsitent eol format while decoding. */
+ encounter an inconsistent eol format while decoding. */
coding->mode |= CODING_MODE_INHIBIT_INCONSISTENT_EOL;
}
}
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
len -= total_skip; len_byte -= total_skip;
}
- /* For converion, we must put the gap before the text in addition to
+ /* For conversion, 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
{
/* The source text ends in invalid codes. Let's just
make them valid buffer contents, and finish conversion. */
- inserted += len_byte;
- inserted_byte += len_byte;
- while (len_byte--)
- *dst++ = *src++;
+ if (multibyte_p)
+ {
+ unsigned char *start = dst;
+
+ inserted += len_byte;
+ while (len_byte--)
+ {
+ int c = *src++;
+ dst += CHAR_STRING (c, dst);
+ }
+
+ inserted_byte += dst - start;
+ }
+ else
+ {
+ inserted += len_byte;
+ inserted_byte += len_byte;
+ while (len_byte--)
+ *dst++ = *src++;
+ }
break;
}
if (result == CODING_FINISH_INTERRUPT)
if (first)
{
/* We have just done the first batch of conversion which was
- stoped because of insufficient gap. Let's reconsider the
+ stopped because of insufficient gap. Let's reconsider the
required gap size (i.e. SRT - DST) now.
We have converted ORIG bytes (== coding->consumed) into
inserted_byte = str_to_multibyte (GPT_ADDR, GAP_SIZE, inserted_byte);
}
- /* If we have shrinked the conversion area, adjust it now. */
+ /* If we shrank the conversion area, adjust it now. */
if (total_skip > 0)
{
if (tail_skip > 0)
&& ! encodep && ! NILP (coding->post_read_conversion))
{
Lisp_Object val;
- int count = specpdl_ptr - specpdl;
if (from != PT)
TEMP_SET_PT_BOTH (from, from_byte);
inhibit_pre_post_conversion = 0;
/* Discard the unwind protect. */
specpdl_ptr--;
- CHECK_NUMBER (val, 0);
+ CHECK_NUMBER (val);
inserted += Z - prev_Z;
}
{
int count = specpdl_ptr - specpdl;
struct gcpro gcpro1;
- struct buffer *prev = current_buffer;
int multibyte = STRING_MULTIBYTE (str);
record_unwind_protect (Fset_buffer, Fcurrent_buffer ());
{
int len;
struct conversion_buffer buf;
- int from, to, to_byte;
+ int from, to_byte;
struct gcpro gcpro1;
Lisp_Object saved_coding_symbol;
int result;
int consumed, consumed_char, produced, produced_char;
from = 0;
- to = XSTRING (str)->size;
to_byte = STRING_BYTES (XSTRING (str));
- saved_coding_symbol = Qnil;
+ saved_coding_symbol = coding->symbol;
+ coding->src_multibyte = STRING_MULTIBYTE (str);
+ coding->dst_multibyte = 1;
if (CODING_REQUIRE_DETECTION (coding))
{
/* See the comments in code_convert_region. */
{
detect_coding (coding, XSTRING (str)->data, to_byte);
if (coding->type == coding_type_undecided)
- coding->type = coding_type_emacs_mule;
+ {
+ coding->type = coding_type_emacs_mule;
+ coding->category_idx = CODING_CATEGORY_IDX_EMACS_MULE;
+ /* As emacs-mule decoder will handle composition, we
+ need this setting to allocate coding->cmp_data
+ later. */
+ coding->composing = COMPOSITION_NO;
+ }
}
if (coding->eol_type == CODING_EOL_UNDECIDED
&& coding->type != coding_type_ccl)
if (coding->eol_type == CODING_EOL_UNDECIDED)
coding->eol_type = CODING_EOL_LF;
/* We had better recover the original eol format if we
- encounter an inconsitent eol format while decoding. */
+ encounter an inconsistent eol format while decoding. */
coding->mode |= CODING_MODE_INHIBIT_INCONSISTENT_EOL;
}
}
- coding->src_multibyte = 0;
- coding->dst_multibyte = (coding->type != coding_type_no_conversion
- && coding->type != coding_type_raw_text);
+ if (coding->type == coding_type_no_conversion
+ || coding->type == coding_type_raw_text)
+ coding->dst_multibyte = 0;
+
require_decoding = CODING_REQUIRE_DECODING (coding);
if (STRING_MULTIBYTE (str))
str = Fstring_as_unibyte (str);
to_byte = STRING_BYTES (XSTRING (str));
nocopy = 1;
+ coding->src_multibyte = 0;
}
/* Try to skip the heading and tailing ASCIIs. */
extend_conversion_buffer (&buf);
else if (result == CODING_FINISH_INCONSISTENT_EOL)
{
+ Lisp_Object eol_type;
+
/* Recover the original EOL format. */
if (coding->eol_type == CODING_EOL_CR)
{
produced += num_eol;
produced_char += num_eol;
}
+ /* Suppress eol-format conversion in the further conversion. */
coding->eol_type = CODING_EOL_LF;
- 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;
+
+
}
}
int len;
struct conversion_buffer buf;
int from, to, to_byte;
- struct gcpro gcpro1;
- Lisp_Object saved_coding_symbol;
int result;
int shrinked_bytes = 0;
Lisp_Object newstr;
to = XSTRING (str)->size;
to_byte = STRING_BYTES (XSTRING (str));
- saved_coding_symbol = Qnil;
-
/* Encoding routines determine the multibyteness of the source text
by coding->src_multibyte. */
coding->src_multibyte = STRING_MULTIBYTE (str);
/*** 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\
-See the documentation of `make-coding-system' for information\n\
-about coding-system objects.")
- (obj)
+ doc: /* Return t if OBJECT is nil or a coding-system.
+See the documentation of `make-coding-system' for information
+about coding-system objects. */)
+ (obj)
Lisp_Object obj;
{
if (NILP (obj))
DEFUN ("read-non-nil-coding-system", Fread_non_nil_coding_system,
Sread_non_nil_coding_system, 1, 1, 0,
- "Read a coding system from the minibuffer, prompting with string PROMPT.")
- (prompt)
+ doc: /* Read a coding system from the minibuffer, prompting with string PROMPT. */)
+ (prompt)
Lisp_Object prompt;
{
Lisp_Object val;
}
DEFUN ("read-coding-system", Fread_coding_system, Sread_coding_system, 1, 2, 0,
- "Read a coding system from the minibuffer, prompting with string PROMPT.\n\
-If the user enters null input, return second argument DEFAULT-CODING-SYSTEM.")
- (prompt, default_coding_system)
+ doc: /* Read a coding system from the minibuffer, prompting with string PROMPT.
+If the user enters null input, return second argument DEFAULT-CODING-SYSTEM. */)
+ (prompt, default_coding_system)
Lisp_Object prompt, default_coding_system;
{
Lisp_Object val;
DEFUN ("check-coding-system", Fcheck_coding_system, Scheck_coding_system,
1, 1, 0,
- "Check validity of CODING-SYSTEM.\n\
-If valid, return CODING-SYSTEM, else signal a `coding-system-error' error.\n\
-It is valid if it is a symbol with a non-nil `coding-system' property.\n\
-The value of property should be a vector of length 5.")
- (coding_system)
+ doc: /* Check validity of CODING-SYSTEM.
+If valid, return CODING-SYSTEM, else signal a `coding-system-error' error.
+It is valid if it is a symbol with a non-nil `coding-system' property.
+The value of property should be a vector of length 5. */)
+ (coding_system)
Lisp_Object coding_system;
{
- CHECK_SYMBOL (coding_system, 0);
+ CHECK_SYMBOL (coding_system);
if (!NILP (Fcoding_system_p (coding_system)))
return coding_system;
while (1)
Lisp_Object eol;
eol = Fget (XCAR (tmp), Qeol_type);
if (VECTORP (eol))
- XCAR (tmp) = XVECTOR (eol)->contents[eol_type];
+ XSETCAR (tmp, XVECTOR (eol)->contents[eol_type]);
}
}
return (highest ? XCAR (val) : val);
DEFUN ("detect-coding-region", Fdetect_coding_region, Sdetect_coding_region,
2, 3, 0,
- "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 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.")
- (start, end, highest)
+ doc: /* Detect coding system of the text in the region between START and END.
+Return a list of possible coding systems ordered by priority.
+
+If only ASCII characters are found, it returns a list of single element
+`undecided' or its subsidiary coding system according to a detected
+end-of-line format.
+
+If optional argument HIGHEST is non-nil, return the coding system of
+highest priority. */)
+ (start, end, highest)
Lisp_Object start, end, highest;
{
int from, to;
int from_byte, to_byte;
+ int include_anchor_byte = 0;
- CHECK_NUMBER_COERCE_MARKER (start, 0);
- CHECK_NUMBER_COERCE_MARKER (end, 1);
+ CHECK_NUMBER_COERCE_MARKER (start);
+ CHECK_NUMBER_COERCE_MARKER (end);
validate_region (&start, &end);
from = XINT (start), to = XINT (end);
if (from < GPT && to >= GPT)
move_gap_both (to, to_byte);
+ /* If we an anchor byte `\0' follows the region, we include it in
+ the detecting source. Then code detectors can handle the tailing
+ byte sequence more accurately.
+ Fix me: This is not an perfect solution. It is better that we
+ add one more argument, say LAST_BLOCK, to all detect_coding_XXX.
+ */
+ if (to == Z || (to == GPT && GAP_SIZE > 0))
+ include_anchor_byte = 1;
return detect_coding_system (BYTE_POS_ADDR (from_byte),
- to_byte - from_byte,
+ to_byte - from_byte + include_anchor_byte,
!NILP (highest),
!NILP (current_buffer
->enable_multibyte_characters));
DEFUN ("detect-coding-string", Fdetect_coding_string, Sdetect_coding_string,
1, 2, 0,
- "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 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.")
- (string, highest)
+ doc: /* Detect coding system of the text in STRING.
+Return a list of possible coding systems ordered by priority.
+
+If only ASCII characters are found, it returns a list of single element
+`undecided' or its subsidiary coding system according to a detected
+end-of-line format.
+
+If optional argument HIGHEST is non-nil, return the coding system of
+highest priority. */)
+ (string, highest)
Lisp_Object string, highest;
{
- CHECK_STRING (string, 0);
+ CHECK_STRING (string);
return detect_coding_system (XSTRING (string)->data,
- STRING_BYTES (XSTRING (string)),
+ /* "+ 1" is to include the anchor byte
+ `\0'. With this, code detectors can
+ handle the tailing bytes more
+ accurately. */
+ STRING_BYTES (XSTRING (string)) + 1,
!NILP (highest),
STRING_MULTIBYTE (string));
}
DEFUN ("find-coding-systems-region-internal",
Ffind_coding_systems_region_internal,
Sfind_coding_systems_region_internal, 2, 2, 0,
- "Internal use only.")
- (start, end)
+ doc: /* Internal use only. */)
+ (start, end)
Lisp_Object start, end;
{
Lisp_Object work_table, safe_codings;
int non_ascii_p = 0;
int single_byte_char_found = 0;
unsigned char *p1, *p1end, *p2, *p2end, *p;
- Lisp_Object args[2];
if (STRINGP (start))
{
{
int from, to, stop;
- CHECK_NUMBER_COERCE_MARKER (start, 0);
- CHECK_NUMBER_COERCE_MARKER (end, 1);
+ CHECK_NUMBER_COERCE_MARKER (start);
+ CHECK_NUMBER_COERCE_MARKER (end);
if (XINT (start) < BEG || XINT (end) > Z || XINT (start) > XINT (end))
args_out_of_range (start, end);
if (NILP (current_buffer->enable_multibyte_characters))
safe_codings = find_safe_codings (p2, p2end, safe_codings, work_table,
&single_byte_char_found);
- if (!single_byte_char_found)
+ if (EQ (safe_codings, Qt))
+ ; /* Nothing to be done. */
+ else if (!single_byte_char_found)
{
/* Append generic coding systems. */
Lisp_Object args[2];
int encodep;
{
struct coding_system coding;
- int from, to, len;
+ int from, to;
- CHECK_NUMBER_COERCE_MARKER (start, 0);
- CHECK_NUMBER_COERCE_MARKER (end, 1);
- CHECK_SYMBOL (coding_system, 2);
+ CHECK_NUMBER_COERCE_MARKER (start);
+ CHECK_NUMBER_COERCE_MARKER (end);
+ CHECK_SYMBOL (coding_system);
validate_region (&start, &end);
from = XFASTINT (start);
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)
+ doc: /* Decode the current region from the specified coding system.
+When called from a program, takes three arguments:
+START, END, and CODING-SYSTEM. START and END are buffer positions.
+This function sets `last-coding-system-used' to the precise coding system
+used (which may be different from CODING-SYSTEM if CODING-SYSTEM is
+not fully specified.)
+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,
3, 3, "r\nzCoding system: ",
- "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\
-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)
+ doc: /* Encode the current region into the specified coding system.
+When called from a program, takes three arguments:
+START, END, and CODING-SYSTEM. START and END are buffer positions.
+This function sets `last-coding-system-used' to the precise coding system
+used (which may be different from CODING-SYSTEM if CODING-SYSTEM is
+not fully specified.)
+It returns the length of the encoded text. */)
+ (start, end, coding_system)
Lisp_Object start, end, coding_system;
{
return code_convert_region1 (start, end, coding_system, 1);
{
struct coding_system coding;
- CHECK_STRING (string, 0);
- CHECK_SYMBOL (coding_system, 1);
+ CHECK_STRING (string);
+ CHECK_SYMBOL (coding_system);
if (NILP (coding_system))
return (NILP (nocopy) ? Fcopy_sequence (string) : string);
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.\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)
+ doc: /* Decode STRING which is encoded in CODING-SYSTEM, and return the result.
+Optional arg NOCOPY non-nil means it is OK to return STRING itself
+if the decoding operation is trivial.
+This function sets `last-coding-system-used' to the precise coding system
+used (which may be different from CODING-SYSTEM if CODING-SYSTEM is
+not fully specified.) */)
+ (string, coding_system, nocopy)
Lisp_Object string, coding_system, 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.\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)
+ doc: /* Encode STRING to CODING-SYSTEM, and return the result.
+Optional arg NOCOPY non-nil means it is OK to return STRING itself
+if the encoding operation is trivial.
+This function sets `last-coding-system-used' to the precise coding system
+used (which may be different from CODING-SYSTEM if CODING-SYSTEM is
+not fully specified.) */)
+ (string, coding_system, nocopy)
Lisp_Object string, coding_system, nocopy;
{
return code_convert_string1 (string, coding_system, nocopy, 1);
{
struct coding_system coding;
- CHECK_STRING (string, 0);
- CHECK_SYMBOL (coding_system, 1);
+ CHECK_STRING (string);
+ CHECK_SYMBOL (coding_system);
if (NILP (coding_system))
return string;
}
\f
DEFUN ("decode-sjis-char", Fdecode_sjis_char, Sdecode_sjis_char, 1, 1, 0,
- "Decode a Japanese character which has CODE in shift_jis encoding.\n\
-Return the corresponding character.")
- (code)
+ doc: /* Decode a Japanese character which has CODE in shift_jis encoding.
+Return the corresponding character. */)
+ (code)
Lisp_Object code;
{
unsigned char c1, c2, s1, s2;
Lisp_Object val;
- CHECK_NUMBER (code, 0);
+ CHECK_NUMBER (code);
s1 = (XFASTINT (code)) >> 8, s2 = (XFASTINT (code)) & 0xFF;
if (s1 == 0)
{
}
DEFUN ("encode-sjis-char", Fencode_sjis_char, Sencode_sjis_char, 1, 1, 0,
- "Encode a Japanese character CHAR to shift_jis encoding.\n\
-Return the corresponding code in SJIS.")
- (ch)
+ doc: /* Encode a Japanese character CHAR to shift_jis encoding.
+Return the corresponding code in SJIS. */)
+ (ch)
Lisp_Object ch;
{
int charset, c1, c2, s1, s2;
Lisp_Object val;
- CHECK_NUMBER (ch, 0);
+ CHECK_NUMBER (ch);
SPLIT_CHAR (XFASTINT (ch), charset, c1, c2);
if (charset == CHARSET_ASCII)
{
}
DEFUN ("decode-big5-char", Fdecode_big5_char, Sdecode_big5_char, 1, 1, 0,
- "Decode a Big5 character which has CODE in BIG5 coding system.\n\
-Return the corresponding character.")
- (code)
+ doc: /* Decode a Big5 character which has CODE in BIG5 coding system.
+Return the corresponding character. */)
+ (code)
Lisp_Object code;
{
int charset;
unsigned char b1, b2, c1, c2;
Lisp_Object val;
- CHECK_NUMBER (code, 0);
+ CHECK_NUMBER (code);
b1 = (XFASTINT (code)) >> 8, b2 = (XFASTINT (code)) & 0xFF;
if (b1 == 0)
{
}
DEFUN ("encode-big5-char", Fencode_big5_char, Sencode_big5_char, 1, 1, 0,
- "Encode the Big5 character CHAR to BIG5 coding system.\n\
-Return the corresponding character code in Big5.")
- (ch)
+ doc: /* Encode the Big5 character CHAR to BIG5 coding system.
+Return the corresponding character code in Big5. */)
+ (ch)
Lisp_Object ch;
{
int charset, c1, c2, b1, b2;
Lisp_Object val;
- CHECK_NUMBER (ch, 0);
+ CHECK_NUMBER (ch);
SPLIT_CHAR (XFASTINT (ch), charset, c1, c2);
if (charset == CHARSET_ASCII)
{
\f
DEFUN ("set-terminal-coding-system-internal",
Fset_terminal_coding_system_internal,
- Sset_terminal_coding_system_internal, 1, 1, 0, "")
- (coding_system)
+ Sset_terminal_coding_system_internal, 1, 1, 0,
+ doc: /* Internal use only. */)
+ (coding_system)
Lisp_Object coding_system;
{
- CHECK_SYMBOL (coding_system, 0);
+ CHECK_SYMBOL (coding_system);
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. */
+ /* Character composition should be disabled. */
terminal_coding.composing = COMPOSITION_DISABLED;
+ /* Error notification should be suppressed. */
+ terminal_coding.suppress_error = 1;
terminal_coding.src_multibyte = 1;
terminal_coding.dst_multibyte = 0;
return Qnil;
DEFUN ("set-safe-terminal-coding-system-internal",
Fset_safe_terminal_coding_system_internal,
- Sset_safe_terminal_coding_system_internal, 1, 1, 0, "")
- (coding_system)
+ Sset_safe_terminal_coding_system_internal, 1, 1, 0,
+ doc: /* Internal use only. */)
+ (coding_system)
Lisp_Object coding_system;
{
- CHECK_SYMBOL (coding_system, 0);
+ CHECK_SYMBOL (coding_system);
setup_coding_system (Fcheck_coding_system (coding_system),
&safe_terminal_coding);
- /* Characer composition should be disabled. */
+ /* Character composition should be disabled. */
safe_terminal_coding.composing = COMPOSITION_DISABLED;
+ /* Error notification should be suppressed. */
+ terminal_coding.suppress_error = 1;
safe_terminal_coding.src_multibyte = 1;
safe_terminal_coding.dst_multibyte = 0;
return Qnil;
DEFUN ("terminal-coding-system",
Fterminal_coding_system, Sterminal_coding_system, 0, 0, 0,
- "Return coding system specified for terminal output.")
- ()
+ doc: /* Return coding system specified for terminal output. */)
+ ()
{
return terminal_coding.symbol;
}
DEFUN ("set-keyboard-coding-system-internal",
Fset_keyboard_coding_system_internal,
- Sset_keyboard_coding_system_internal, 1, 1, 0, "")
- (coding_system)
+ Sset_keyboard_coding_system_internal, 1, 1, 0,
+ doc: /* Internal use only. */)
+ (coding_system)
Lisp_Object coding_system;
{
- CHECK_SYMBOL (coding_system, 0);
+ CHECK_SYMBOL (coding_system);
setup_coding_system (Fcheck_coding_system (coding_system), &keyboard_coding);
- /* Characer composition should be disabled. */
+ /* Character composition should be disabled. */
keyboard_coding.composing = COMPOSITION_DISABLED;
return Qnil;
}
DEFUN ("keyboard-coding-system",
Fkeyboard_coding_system, Skeyboard_coding_system, 0, 0, 0,
- "Return coding system specified for decoding keyboard input.")
- ()
+ doc: /* Return coding system specified for decoding keyboard input. */)
+ ()
{
return keyboard_coding.symbol;
}
\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\
-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\
-\n\
-The first argument OPERATION specifies an I/O primitive:\n\
- For file I/O, `insert-file-contents' or `write-region'.\n\
- For process I/O, `call-process', `call-process-region', or `start-process'.\n\
- For network I/O, `open-network-stream'.\n\
-\n\
-The remaining arguments should be the same arguments that were passed\n\
-to the primitive. Depending on which primitive, one of those arguments\n\
-is selected as the TARGET. For example, if OPERATION does file I/O,\n\
-whichever argument specifies the file name is TARGET.\n\
-\n\
-TARGET has a meaning which depends on OPERATION:\n\
- For file I/O, TARGET is a file name.\n\
- For process I/O, TARGET is a process name.\n\
- For network I/O, TARGET is a service name or a port number\n\
-\n\
-This function looks up what specified for TARGET in,\n\
-`file-coding-system-alist', `process-coding-system-alist',\n\
-or `network-coding-system-alist' depending on OPERATION.\n\
-They may specify a coding system, a cons of coding systems,\n\
-or a function symbol to call.\n\
-In the last case, we call the function with one argument,\n\
-which is a list of all the arguments given to this function.")
- (nargs, args)
+ doc: /* Choose a coding system for an operation based on the target name.
+The value names a pair of coding systems: (DECODING-SYSTEM . ENCODING-SYSTEM).
+DECODING-SYSTEM is the coding system to use for decoding
+\(in case OPERATION does decoding), and ENCODING-SYSTEM is the coding system
+for encoding (in case OPERATION does encoding).
+
+The first argument OPERATION specifies an I/O primitive:
+ For file I/O, `insert-file-contents' or `write-region'.
+ For process I/O, `call-process', `call-process-region', or `start-process'.
+ For network I/O, `open-network-stream'.
+
+The remaining arguments should be the same arguments that were passed
+to the primitive. Depending on which primitive, one of those arguments
+is selected as the TARGET. For example, if OPERATION does file I/O,
+whichever argument specifies the file name is TARGET.
+
+TARGET has a meaning which depends on OPERATION:
+ For file I/O, TARGET is a file name.
+ For process I/O, TARGET is a process name.
+ For network I/O, TARGET is a service name or a port number
+
+This function looks up what specified for TARGET in,
+`file-coding-system-alist', `process-coding-system-alist',
+or `network-coding-system-alist' depending on OPERATION.
+They may specify a coding system, a cons of coding systems,
+or a function symbol to call.
+In the last case, we call the function with one argument,
+which is a list of all the arguments given to this function.
+
+usage: (find-operation-coding-system OPERATION ARGUMENTS ...) */)
+ (nargs, args)
int nargs;
Lisp_Object *args;
{
operation = args[0];
if (!SYMBOLP (operation)
|| !INTEGERP (target_idx = Fget (operation, Qtarget_idx)))
- error ("Invalid first arguement");
+ error ("Invalid first argument");
if (nargs < 1 + XINT (target_idx))
error ("Too few arguments for operation: %s",
XSYMBOL (operation)->name->data);
target = args[XINT (target_idx) + 1];
if (!(STRINGP (target)
|| (EQ (operation, Qopen_network_stream) && INTEGERP (target))))
- error ("Invalid %dth argument", XINT (target_idx) + 1);
+ error ("Invalid argument %d", XINT (target_idx) + 1);
chain = ((EQ (operation, Qinsert_file_contents)
|| EQ (operation, Qwrite_region))
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 any coding categories are changed, you must\n\
-call this function")
- ()
+ doc: /* Update internal database for ISO2022 and CCL based coding systems.
+When values of any coding categories are changed, you must
+call this function. */)
+ ()
{
int i;
{
Lisp_Object val;
- val = XSYMBOL (XVECTOR (Vcoding_category_table)->contents[i])->value;
+ val = SYMBOL_VALUE (XVECTOR (Vcoding_category_table)->contents[i]);
if (!NILP (val))
{
if (! coding_system_table[i])
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.")
- ()
+ doc: /* Update internal database for the current value of `coding-category-list'.
+This function is internal use only. */)
+ ()
{
int i = 0, idx;
Lisp_Object val;
defsubr (&Sset_coding_priority_internal);
DEFVAR_LISP ("coding-system-list", &Vcoding_system_list,
- "List of coding systems.\n\
-\n\
-Do not alter the value of this variable manually. This variable should be\n\
-updated by the functions `make-coding-system' and\n\
-`define-coding-system-alias'.");
+ doc: /* List of coding systems.
+
+Do not alter the value of this variable manually. This variable should be
+updated by the functions `make-coding-system' and
+`define-coding-system-alias'. */);
Vcoding_system_list = Qnil;
DEFVAR_LISP ("coding-system-alist", &Vcoding_system_alist,
- "Alist of coding system names.\n\
-Each element is one element list of coding system name.\n\
-This variable is given to `completing-read' as TABLE argument.\n\
-\n\
-Do not alter the value of this variable manually. This variable should be\n\
-updated by the functions `make-coding-system' and\n\
-`define-coding-system-alias'.");
+ doc: /* Alist of coding system names.
+Each element is one element list of coding system name.
+This variable is given to `completing-read' as TABLE argument.
+
+Do not alter the value of this variable manually. This variable should be
+updated by the functions `make-coding-system' and
+`define-coding-system-alias'. */);
Vcoding_system_alist = Qnil;
DEFVAR_LISP ("coding-category-list", &Vcoding_category_list,
- "List of coding-categories (symbols) ordered by priority.");
+ doc: /* List of coding-categories (symbols) ordered by priority.
+
+On detecting a coding system, Emacs tries code detection algorithms
+associated with each coding-category one by one in this order. When
+one algorithm agrees with a byte sequence of source text, the coding
+system bound to the corresponding coding-category is selected. */);
{
int i;
}
DEFVAR_LISP ("coding-system-for-read", &Vcoding_system_for_read,
- "Specify the coding system for read 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 decoding on read operation.\n\
-If not, an appropriate element 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'.");
+ doc: /* Specify the coding system for read operations.
+It is useful to bind this variable with `let', but do not set it globally.
+If the value is a coding system, it is used for decoding on read operation.
+If not, an appropriate element is used from one of the coding system alists:
+There are three such tables, `file-coding-system-alist',
+`process-coding-system-alist', and `network-coding-system-alist'. */);
Vcoding_system_for_read = Qnil;
DEFVAR_LISP ("coding-system-for-write", &Vcoding_system_for_write,
- "Specify the coding system for write operations.\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'.\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.");
+ doc: /* Specify the coding system for write operations.
+Programs bind this variable with `let', but you should not set it globally.
+If the value is a coding system, it is used for encoding of output,
+when writing it to a file and when sending it to a file or subprocess.
+
+If this does not specify a coding system, an appropriate element
+is used from one of the coding system alists:
+There are three such tables, `file-coding-system-alist',
+`process-coding-system-alist', and `network-coding-system-alist'.
+For output to files, if the above procedure does not specify a coding system,
+the value of `buffer-file-coding-system' is used. */);
Vcoding_system_for_write = Qnil;
DEFVAR_LISP ("last-coding-system-used", &Vlast_coding_system_used,
- "Coding system used in the latest file or process I/O.");
+ doc: /* Coding system used in the latest file or process I/O. */);
Vlast_coding_system_used = Qnil;
DEFVAR_BOOL ("inhibit-eol-conversion", &inhibit_eol_conversion,
- "*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.");
+ doc: /* *Non-nil means always inhibit code conversion of end-of-line format.
+See info node `Coding Systems' and info node `Text and Binary' concerning
+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.");
+ doc: /* Non-nil means process buffer inherits coding system of process output.
+Bind it to t if the process output is to be treated as if it were a file
+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\
-where PATTERN is a regular expression matching a file name,\n\
-VAL is a coding system, a cons of coding systems, or a function symbol.\n\
-If VAL is a coding system, it is used for both decoding and encoding\n\
-the file contents.\n\
-If VAL is a cons of coding systems, the car part is used for decoding,\n\
-and the cdr part is used for encoding.\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'\n\
-and the variable `auto-coding-alist'.");
+ doc: /* Alist to decide a coding system to use for a file I/O operation.
+The format is ((PATTERN . VAL) ...),
+where PATTERN is a regular expression matching a file name,
+VAL is a coding system, a cons of coding systems, or a function symbol.
+If VAL is a coding system, it is used for both decoding and encoding
+the file contents.
+If VAL is a cons of coding systems, the car part is used for decoding,
+and the cdr part is used for encoding.
+If VAL is a function symbol, the function must return a coding system
+or a cons of coding systems which are used as above.
+
+See also the function `find-operation-coding-system'
+and the variable `auto-coding-alist'. */);
Vfile_coding_system_alist = Qnil;
DEFVAR_LISP ("process-coding-system-alist", &Vprocess_coding_system_alist,
- "Alist to decide a coding system to use for a process I/O operation.\n\
-The format is ((PATTERN . VAL) ...),\n\
-where PATTERN is a regular expression matching a program name,\n\
-VAL is a coding system, a cons of coding systems, or a function symbol.\n\
-If VAL is a coding system, it is used for both decoding what received\n\
-from the program and encoding what sent to the program.\n\
-If VAL is a cons of coding systems, the car part is used for decoding,\n\
-and the cdr part is used for encoding.\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'.");
+ doc: /* Alist to decide a coding system to use for a process I/O operation.
+The format is ((PATTERN . VAL) ...),
+where PATTERN is a regular expression matching a program name,
+VAL is a coding system, a cons of coding systems, or a function symbol.
+If VAL is a coding system, it is used for both decoding what received
+from the program and encoding what sent to the program.
+If VAL is a cons of coding systems, the car part is used for decoding,
+and the cdr part is used for encoding.
+If VAL is a function symbol, the function must return a coding system
+or a cons of coding systems which are used as above.
+
+See also the function `find-operation-coding-system'. */);
Vprocess_coding_system_alist = Qnil;
DEFVAR_LISP ("network-coding-system-alist", &Vnetwork_coding_system_alist,
- "Alist to decide a coding system to use for a network I/O operation.\n\
-The format is ((PATTERN . VAL) ...),\n\
-where PATTERN is a regular expression matching a network service name\n\
-or is a port number to connect to,\n\
-VAL is a coding system, a cons of coding systems, or a function symbol.\n\
-If VAL is a coding system, it is used for both decoding what received\n\
-from the network stream and encoding what sent to the network stream.\n\
-If VAL is a cons of coding systems, the car part is used for decoding,\n\
-and the cdr part is used for encoding.\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'.");
+ doc: /* Alist to decide a coding system to use for a network I/O operation.
+The format is ((PATTERN . VAL) ...),
+where PATTERN is a regular expression matching a network service name
+or is a port number to connect to,
+VAL is a coding system, a cons of coding systems, or a function symbol.
+If VAL is a coding system, it is used for both decoding what received
+from the network stream and encoding what sent to the network stream.
+If VAL is a cons of coding systems, the car part is used for decoding,
+and the cdr part is used for encoding.
+If VAL is a function symbol, the function must return a coding system
+or a cons of coding systems which are used as above.
+
+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.");
+ doc: /* Coding system to use with system messages.
+Also used for decoding keyboard input on X Window system. */);
Vlocale_coding_system = Qnil;
/* The eol mnemonics are reset in startup.el system-dependently. */
DEFVAR_LISP ("eol-mnemonic-unix", &eol_mnemonic_unix,
- "*String displayed in mode line for UNIX-like (LF) end-of-line format.");
+ doc: /* *String displayed in mode line for UNIX-like (LF) end-of-line format. */);
eol_mnemonic_unix = build_string (":");
DEFVAR_LISP ("eol-mnemonic-dos", &eol_mnemonic_dos,
- "*String displayed in mode line for DOS-like (CRLF) end-of-line format.");
+ doc: /* *String displayed in mode line for DOS-like (CRLF) end-of-line format. */);
eol_mnemonic_dos = build_string ("\\");
DEFVAR_LISP ("eol-mnemonic-mac", &eol_mnemonic_mac,
- "*String displayed in mode line for MAC-like (CR) end-of-line format.");
+ doc: /* *String displayed in mode line for MAC-like (CR) end-of-line format. */);
eol_mnemonic_mac = build_string ("/");
DEFVAR_LISP ("eol-mnemonic-undecided", &eol_mnemonic_undecided,
- "*String displayed in mode line when end-of-line format is not yet determined.");
+ doc: /* *String displayed in mode line when end-of-line format is not yet determined. */);
eol_mnemonic_undecided = build_string (":");
DEFVAR_LISP ("enable-character-translation", &Venable_character_translation,
- "*Non-nil enables character translation while encoding and decoding.");
+ doc: /* *Non-nil enables character translation while encoding and decoding. */);
Venable_character_translation = Qt;
DEFVAR_LISP ("standard-translation-table-for-decode",
- &Vstandard_translation_table_for_decode,
- "Table for translating characters while decoding.");
+ &Vstandard_translation_table_for_decode,
+ doc: /* Table for translating characters while decoding. */);
Vstandard_translation_table_for_decode = Qnil;
DEFVAR_LISP ("standard-translation-table-for-encode",
- &Vstandard_translation_table_for_encode,
- "Table for translationg characters while encoding.");
+ &Vstandard_translation_table_for_encode,
+ doc: /* Table for translating characters while encoding. */);
Vstandard_translation_table_for_encode = Qnil;
DEFVAR_LISP ("charset-revision-table", &Vcharset_revision_alist,
- "Alist of charsets vs revision numbers.\n\
-While encoding, if a charset (car part of an element) is found,\n\
-designate it with the escape sequence identifing revision (cdr part of the element).");
+ doc: /* Alist of charsets vs revision numbers.
+While encoding, if a charset (car part of an element) is found,
+designate it with the escape sequence identifying revision (cdr part of the element). */);
Vcharset_revision_alist = Qnil;
DEFVAR_LISP ("default-process-coding-system",
&Vdefault_process_coding_system,
- "Cons of coding systems used for process I/O by default.\n\
-The car part is used for decoding a process output,\n\
-the cdr part is used for encoding a text to be sent to a process.");
+ doc: /* Cons of coding systems used for process I/O by default.
+The car part is used for decoding a process output,
+the cdr part is used for encoding a text to be sent to a process. */);
Vdefault_process_coding_system = Qnil;
DEFVAR_LISP ("latin-extra-code-table", &Vlatin_extra_code_table,
- "Table of extra Latin codes in the range 128..159 (inclusive).\n\
-This is a vector of length 256.\n\
-If Nth element is non-nil, the existence of code N in a file\n\
-\(or output of subprocess) doesn't prevent it to be detected as\n\
-a coding system of ISO 2022 variant which has a flag\n\
-`accept-latin-extra-code' t (e.g. iso-latin-1) on reading a file\n\
-or reading output of a subprocess.\n\
-Only 128th through 159th elements has a meaning.");
+ doc: /* Table of extra Latin codes in the range 128..159 (inclusive).
+This is a vector of length 256.
+If Nth element is non-nil, the existence of code N in a file
+\(or output of subprocess) doesn't prevent it to be detected as
+a coding system of ISO 2022 variant which has a flag
+`accept-latin-extra-code' t (e.g. iso-latin-1) on reading a file
+or reading output of a subprocess.
+Only 128th through 159th elements has a meaning. */);
Vlatin_extra_code_table = Fmake_vector (make_number (256), Qnil);
DEFVAR_LISP ("select-safe-coding-system-function",
&Vselect_safe_coding_system_function,
- "Function to call to select safe coding system for encoding a text.\n\
-\n\
-If set, this function is called to force a user to select a proper\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-coding-system' (which see).");
+ doc: /* Function to call to select safe coding system for encoding a text.
+
+If set, this function is called to force a user to select a proper
+coding system which can encode the text in the case that a default
+coding system used in each operation can't encode the text.
+
+The default value is `select-safe-coding-system' (which see). */);
Vselect_safe_coding_system_function = Qnil;
DEFVAR_LISP ("char-coding-system-table", &Vchar_coding_system_table,
- "Char-table containing safe coding systems of each characters.\n\
-Each element doesn't include such generic coding systems that can\n\
-encode any characters. They are in the first extra slot.");
+ doc: /* Char-table containing safe coding systems of each characters.
+Each element doesn't include such generic coding systems that can
+encode any characters. They are in the first extra slot. */);
Vchar_coding_system_table = Fmake_char_table (Qchar_coding_system, Qnil);
DEFVAR_BOOL ("inhibit-iso-escape-detection",
&inhibit_iso_escape_detection,
- "If non-nil, Emacs ignores ISO2022's escape sequence on code detection.\n\
-\n\
-By default, on reading a file, Emacs tries to detect how the text is\n\
-encoded. This code detection is sensitive to escape sequences. If\n\
-the sequence is valid as ISO2022, the code is determined as one of\n\
-the ISO2022 encodings, and the file is decoded by the corresponding\n\
-coding system (e.g. `iso-2022-7bit').\n\
-\n\
-However, there may be a case that you want to read escape sequences in\n\
-a file as is. In such a case, you can set this variable to non-nil.\n\
-Then, as the code detection ignores any escape sequences, no file is\n\
-detected as encoded in some ISO2022 encoding. The result is that all\n\
-escape sequences become visible in a buffer.\n\
-\n\
-The default value is nil, and it is strongly recommended not to change\n\
-it. That is because many Emacs Lisp source files that contain\n\
-non-ASCII characters are encoded by the coding system `iso-2022-7bit'\n\
-in Emacs's distribution, and they won't be decoded correctly on\n\
-reading if you suppress escape sequence detection.\n\
-\n\
-The other way to read escape sequences in a file without decoding is\n\
-to explicitly specify some coding system that doesn't use ISO2022's\n\
-escape sequence (e.g `latin-1') on reading by \\[universal-coding-system-argument].");
+ doc: /* If non-nil, Emacs ignores ISO2022's escape sequence on code detection.
+
+By default, on reading a file, Emacs tries to detect how the text is
+encoded. This code detection is sensitive to escape sequences. If
+the sequence is valid as ISO2022, the code is determined as one of
+the ISO2022 encodings, and the file is decoded by the corresponding
+coding system (e.g. `iso-2022-7bit').
+
+However, there may be a case that you want to read escape sequences in
+a file as is. In such a case, you can set this variable to non-nil.
+Then, as the code detection ignores any escape sequences, no file is
+detected as encoded in some ISO2022 encoding. The result is that all
+escape sequences become visible in a buffer.
+
+The default value is nil, and it is strongly recommended not to change
+it. That is because many Emacs Lisp source files that contain
+non-ASCII characters are encoded by the coding system `iso-2022-7bit'
+in Emacs's distribution, and they won't be decoded correctly on
+reading if you suppress escape sequence detection.
+
+The other way to read escape sequences in a file without decoding is
+to explicitly specify some coding system that doesn't use ISO2022's
+escape sequence (e.g `latin-1') on reading by \\[universal-coding-system-argument]. */);
inhibit_iso_escape_detection = 0;
}
HCoop / bpt / emacs.git / blobdiff