2. Emacs' internal format (emacs-mule) handlers
3. ISO2022 handlers
4. Shift-JIS and BIG5 handlers
- 5. End-of-line handlers
- 6. C library functions
- 7. Emacs Lisp library functions
- 8. Post-amble
+ 5. CCL handlers
+ 6. End-of-line handlers
+ 7. C library functions
+ 8. Emacs Lisp library functions
+ 9. Post-amble
*/
Lisp_Object Qno_conversion, Qundecided;
Lisp_Object Qcoding_system_history;
Lisp_Object Qsafe_charsets;
+Lisp_Object Qvalid_codes;
extern Lisp_Object Qinsert_file_contents, Qwrite_region;
Lisp_Object Qcall_process, Qcall_process_region, Qprocess_argument;
Lisp_Object Vlast_coding_system_used;
/* A vector of length 256 which contains information about special
- Latin codes (espepcially for dealing with Microsoft code). */
+ Latin codes (especially for dealing with Microsoft codes). */
Lisp_Object Vlatin_extra_code_table;
/* Flag to inhibit code conversion of end-of-line format. */
/* Coding system of what is sent from terminal keyboard. */
struct coding_system keyboard_coding;
+/* Default coding system to be used to write a file. */
+struct coding_system default_buffer_file_coding;
+
Lisp_Object Vfile_coding_system_alist;
Lisp_Object Vprocess_coding_system_alist;
Lisp_Object Vnetwork_coding_system_alist;
"coding-category-iso-8-2",
"coding-category-iso-7-else",
"coding-category-iso-8-else",
+ "coding-category-ccl",
"coding-category-big5",
"coding-category-raw-text",
"coding-category-binary"
enum iso_code_class_type iso_code_class[256];
-#define CHARSET_OK(idx, charset) \
- (coding_system_table[idx]->safe_charsets[charset] \
- || (CODING_SPEC_ISO_REQUESTED_DESIGNATION \
- (coding_system_table[idx], charset) \
- != CODING_SPEC_ISO_NO_REQUESTED_DESIGNATION))
+#define CHARSET_OK(idx, charset) \
+ (coding_system_table[idx] \
+ && (coding_system_table[idx]->safe_charsets[charset] \
+ || (CODING_SPEC_ISO_REQUESTED_DESIGNATION \
+ (coding_system_table[idx], charset) \
+ != CODING_SPEC_ISO_NO_REQUESTED_DESIGNATION)))
#define SHIFT_OUT_OK(idx) \
(CODING_SPEC_ISO_INITIAL_DESIGNATION (coding_system_table[idx], 1) >= 0)
{
int mask = CODING_CATEGORY_MASK_ISO;
int mask_found = 0;
- int reg[4], shift_out = 0;
+ int reg[4], shift_out = 0, single_shifting = 0;
int c, c1, i, charset;
reg[0] = CHARSET_ASCII, reg[1] = reg[2] = reg[3] = -1;
switch (c)
{
case ISO_CODE_ESC:
+ single_shifting = 0;
if (src >= src_end)
break;
c = *src++;
break;
case ISO_CODE_SO:
+ single_shifting = 0;
if (shift_out == 0
&& (reg[1] >= 0
|| SHIFT_OUT_OK (CODING_CATEGORY_IDX_ISO_7_ELSE)
break;
case ISO_CODE_SI:
+ single_shifting = 0;
if (shift_out == 1)
{
/* Locking shift in. */
break;
case ISO_CODE_CSI:
+ single_shifting = 0;
case ISO_CODE_SS2:
case ISO_CODE_SS3:
{
if (coding_system_table[CODING_CATEGORY_IDX_ISO_8_2]->flags
& CODING_FLAG_ISO_SINGLE_SHIFT)
newmask |= CODING_CATEGORY_MASK_ISO_8_2;
+ single_shifting = 1;
}
if (VECTORP (Vlatin_extra_code_table)
&& !NILP (XVECTOR (Vlatin_extra_code_table)->contents[c]))
default:
if (c < 0x80)
- break;
+ {
+ single_shifting = 0;
+ break;
+ }
else if (c < 0xA0)
{
+ single_shifting = 0;
if (VECTORP (Vlatin_extra_code_table)
&& !NILP (XVECTOR (Vlatin_extra_code_table)->contents[c]))
{
mask &= ~(CODING_CATEGORY_MASK_ISO_7BIT
| CODING_CATEGORY_MASK_ISO_7_ELSE);
mask_found |= CODING_CATEGORY_MASK_ISO_8_1;
- while (src < src_end && *src >= 0xA0)
- src++;
- if ((src - src_begin - 1) & 1 && src < src_end)
- mask &= ~CODING_CATEGORY_MASK_ISO_8_2;
- else
- mask_found |= CODING_CATEGORY_MASK_ISO_8_2;
+ /* Check the length of succeeding codes of the range
+ 0xA0..0FF. If the byte length is odd, we exclude
+ CODING_CATEGORY_MASK_ISO_8_2. We can check this only
+ when we are not single shifting. */
+ if (!single_shifting)
+ {
+ while (src < src_end && *src >= 0xA0)
+ src++;
+ if ((src - src_begin - 1) & 1 && src < src_end)
+ mask &= ~CODING_CATEGORY_MASK_ISO_8_2;
+ else
+ mask_found |= CODING_CATEGORY_MASK_ISO_8_2;
+ }
}
break;
}
*dst++ = 0xFF; \
coding->composing += 2; \
} \
- if ((charset) >= 0) \
+ if (charset_alt >= 0) \
{ \
- if (CHARSET_DIMENSION (charset) == 2) \
+ if (CHARSET_DIMENSION (charset_alt) == 2) \
{ \
ONE_MORE_BYTE (c2); \
if (iso_code_class[(c2) & 0x7F] != ISO_0x20_or_0x7F \
&& iso_code_class[(c2) & 0x7F] != ISO_graphic_plane_0) \
{ \
src--; \
- c2 = ' '; \
+ charset_alt = CHARSET_ASCII; \
} \
} \
if (!NILP (translation_table) \
&& ((c_alt = translate_char (translation_table, \
- -1, (charset), c1, c2)) >= 0)) \
+ -1, charset_alt, c1, c2)) >= 0)) \
SPLIT_CHAR (c_alt, charset_alt, c1, c2); \
} \
if (charset_alt == CHARSET_ASCII || charset_alt < 0) \
(character set) (range)
ASCII 0x00 .. 0x7F
KATAKANA-JISX0201 0xA0 .. 0xDF
- JISX0208 (1st byte) 0x80 .. 0x9F and 0xE0 .. 0xFF
+ JISX0208 (1st byte) 0x80 .. 0x9F and 0xE0 .. 0xEF
(2nd byte) 0x40 .. 0xFF
-------------------------------
}
else if (c1 < 0x80)
DECODE_SJIS_BIG5_CHARACTER (charset_ascii, c1, /* dummy */ c2);
- else if (c1 < 0xA0)
+ else
{
- /* SJIS -> JISX0208 */
if (sjis_p)
{
- ONE_MORE_BYTE (c2);
- if (c2 >= 0x40)
+ if (c1 < 0xA0 || (c1 >= 0xE0 && c1 < 0xF0))
{
- DECODE_SJIS (c1, c2, c3, c4);
- DECODE_SJIS_BIG5_CHARACTER (charset_jisx0208, c3, c4);
+ /* SJIS -> JISX0208 */
+ ONE_MORE_BYTE (c2);
+ if (c2 >= 0x40)
+ {
+ DECODE_SJIS (c1, c2, c3, c4);
+ DECODE_SJIS_BIG5_CHARACTER (charset_jisx0208, c3, c4);
+ }
+ else
+ goto label_invalid_code_2;
}
+ else if (c1 < 0xE0)
+ /* SJIS -> JISX0201-Kana */
+ DECODE_SJIS_BIG5_CHARACTER (charset_katakana_jisx0201, c1,
+ /* dummy */ c2);
else
- goto label_invalid_code_2;
+ goto label_invalid_code_1;
}
- else
- goto label_invalid_code_1;
- }
- else if (c1 < 0xE0)
- {
- /* SJIS -> JISX0201-Kana, BIG5 -> Big5 */
- if (sjis_p)
- DECODE_SJIS_BIG5_CHARACTER (charset_katakana_jisx0201, c1,
- /* dummy */ c2);
else
{
- int charset;
-
- ONE_MORE_BYTE (c2);
- if ((c2 >= 0x40 && c2 <= 0x7E) || (c2 >= 0xA1 && c2 <= 0xFE))
+ /* BIG5 -> Big5 */
+ if (c1 >= 0xA1 && c1 <= 0xFE)
{
- DECODE_BIG5 (c1, c2, charset, c3, c4);
- DECODE_SJIS_BIG5_CHARACTER (charset, c3, c4);
- }
- else
- goto label_invalid_code_2;
- }
- }
- else /* C1 >= 0xE0 */
- {
- /* SJIS -> JISX0208, BIG5 -> Big5 */
- if (sjis_p)
- {
- ONE_MORE_BYTE (c2);
- if (c2 >= 0x40)
- {
- DECODE_SJIS (c1, c2, c3, c4);
- DECODE_SJIS_BIG5_CHARACTER (charset_jisx0208, c3, c4);
- }
- else
- goto label_invalid_code_2;
- }
- else
- {
- int charset;
+ ONE_MORE_BYTE (c2);
+ if ((c2 >= 0x40 && c2 <= 0x7E) || (c2 >= 0xA1 && c2 <= 0xFE))
+ {
+ int charset;
- ONE_MORE_BYTE (c2);
- if ((c2 >= 0x40 && c2 <= 0x7E) || (c2 >= 0xA1 && c2 <= 0xFE))
- {
- DECODE_BIG5 (c1, c2, charset, c3, c4);
- DECODE_SJIS_BIG5_CHARACTER (charset, c3, c4);
+ DECODE_BIG5 (c1, c2, charset, c3, c4);
+ DECODE_SJIS_BIG5_CHARACTER (charset, c3, c4);
+ }
+ else
+ goto label_invalid_code_2;
}
else
- goto label_invalid_code_2;
+ goto label_invalid_code_1;
}
}
continue;
}
\f
-/*** 5. End-of-line handlers ***/
+/*** 5. CCL handlers ***/
+
+/* See the above "GENERAL NOTES on `detect_coding_XXX ()' functions".
+ Check if a text is encoded in a coding system of which
+ encoder/decoder are written in CCL program. If it is, return
+ CODING_CATEGORY_MASK_CCL, else return 0. */
+
+int
+detect_coding_ccl (src, src_end)
+ unsigned char *src, *src_end;
+{
+ unsigned char *valid;
+
+ /* No coding system is assigned to coding-category-ccl. */
+ if (!coding_system_table[CODING_CATEGORY_IDX_CCL])
+ return 0;
+
+ valid = coding_system_table[CODING_CATEGORY_IDX_CCL]->spec.ccl.valid_codes;
+ while (src < src_end)
+ {
+ if (! valid[*src]) return 0;
+ src++;
+ }
+ return CODING_CATEGORY_MASK_CCL;
+}
+
+\f
+/*** 6. End-of-line handlers ***/
/* See the above "GENERAL NOTES on `decode_coding_XXX ()' functions".
This function is called only when `coding->eol_type' is
else
safe_bcopy (source, destination, src_bytes);
src += src_bytes;
- dst += dst_bytes;
+ dst += src_bytes;
coding->fake_multibyte = 1;
break;
}
if (dst_bytes)
bcopy (source, destination, src_bytes);
else
- {
- safe_bcopy (source, destination, src_bytes);
- dst_bytes = src_bytes;
- }
- if (coding->eol_type == CODING_EOL_CRLF)
+ safe_bcopy (source, destination, src_bytes);
+ dst_bytes = src_bytes;
+ if (coding->eol_type == CODING_EOL_CR)
{
while (src_bytes--)
{
if ((c = *dst++) == '\n')
dst[-1] = '\r';
else if (BASE_LEADING_CODE_P (c))
- coding->fake_multibyte = 1;
+ coding->fake_multibyte = 1;
}
}
else
}
\f
-/*** 6. C library functions ***/
+/*** 7. C library functions ***/
/* In Emacs Lisp, coding system is represented by a Lisp symbol which
has a property `coding-system'. The value of this property is a
}
else if (CONSP (flags[i]))
{
- Lisp_Object tail = flags[i];
+ Lisp_Object tail;
+ tail = flags[i];
coding->flags |= CODING_FLAG_ISO_DESIGNATION;
if (INTEGERP (XCONS (tail)->car)
coding->common_flags
|= CODING_REQUIRE_DECODING_MASK | CODING_REQUIRE_ENCODING_MASK;
{
- Lisp_Object val = XVECTOR (coding_spec)->contents[4];
+ 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))
}
else
goto label_invalid_coding_system;
+
+ bzero (coding->spec.ccl.valid_codes, 256);
+ val = Fplist_get (plist, Qvalid_codes);
+ if (CONSP (val))
+ {
+ Lisp_Object this;
+
+ for (; CONSP (val); val = XCONS (val)->cdr)
+ {
+ this = XCONS (val)->car;
+ 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))
+ {
+ int start = XINT (XCONS (this)->car);
+ int end = XINT (XCONS (this)->cdr);
+
+ if (start >= 0 && start <= end && end < 256)
+ while (start < end)
+ coding->spec.ccl.valid_codes[start++] = 1;
+ }
+ }
+ }
}
coding->common_flags |= CODING_REQUIRE_FLUSHING_MASK;
break;
return -1;
}
+/* Setup raw-text or one of its subsidiaries in the structure
+ coding_system CODING according to the already setup value eol_type
+ in CODING. CODING should be setup for some coding system in
+ advance. */
+
+void
+setup_raw_text_coding_system (coding)
+ struct coding_system *coding;
+{
+ if (coding->type != coding_type_raw_text)
+ {
+ coding->symbol = Qraw_text;
+ coding->type = coding_type_raw_text;
+ if (coding->eol_type != CODING_EOL_UNDECIDED)
+ {
+ Lisp_Object subsidiaries;
+ subsidiaries = Fget (Qraw_text, Qeol_type);
+
+ if (VECTORP (subsidiaries)
+ && XVECTOR (subsidiaries)->size == 3)
+ coding->symbol
+ = XVECTOR (subsidiaries)->contents[coding->eol_type];
+ }
+ }
+ return;
+}
+
/* Emacs has a mechanism to automatically detect a coding system if it
is one of Emacs' internal format, ISO2022, SJIS, and BIG5. But,
it's impossible to distinguish some coding systems accurately
as BIG5. Assigned the coding-system (Lisp symbol)
`cn-big5' by default.
+ o coding-category-ccl
+
+ The category for a coding system of which encoder/decoder is
+ written in CCL programs. The default value is nil, i.e., no
+ coding system is assigned.
+
o coding-category-binary
The category for a coding system not categorized in any of the
/* We found nothing other than ASCII. There's nothing to do. */
return 0;
+ c = *src;
/* The text seems to be encoded in some multilingual coding system.
Now, try to find in which coding system the text is encoded. */
if (c < 0x80)
| CODING_CATEGORY_MASK_SJIS
| CODING_CATEGORY_MASK_BIG5);
+ /* Or, we may have to consider the possibility of CCL. */
+ if (coding_system_table[CODING_CATEGORY_IDX_CCL]
+ && (coding_system_table[CODING_CATEGORY_IDX_CCL]
+ ->spec.ccl.valid_codes)[c])
+ try |= CODING_CATEGORY_MASK_CCL;
+
mask = 0;
if (priorities)
{
mask = detect_coding_big5 (src, src_end);
else if (priorities[i] & try & CODING_CATEGORY_MASK_EMACS_MULE)
mask = detect_coding_emacs_mule (src, src_end);
+ else if (priorities[i] & try & CODING_CATEGORY_MASK_CCL)
+ mask = detect_coding_ccl (src, src_end);
else if (priorities[i] & CODING_CATEGORY_MASK_RAW_TEXT)
mask = CODING_CATEGORY_MASK_RAW_TEXT;
else if (priorities[i] & CODING_CATEGORY_MASK_BINARY)
if (try & CODING_CATEGORY_MASK_BIG5)
mask |= detect_coding_big5 (src, src_end);
if (try & CODING_CATEGORY_MASK_EMACS_MULE)
- mask |= detect_coding_emacs_mule (src, src_end);
+ mask |= detect_coding_emacs_mule (src, src_end);
+ if (try & CODING_CATEGORY_MASK_CCL)
+ mask |= detect_coding_ccl (src, src_end);
}
return (mask | CODING_CATEGORY_MASK_RAW_TEXT | CODING_CATEGORY_MASK_BINARY);
{
unsigned int idx;
int skip, mask, i;
- Lisp_Object val = Vcoding_category_list;
+ Lisp_Object val;
+ val = Vcoding_category_list;
mask = detect_coding_mask (src, src_bytes, coding_priorities, &skip);
coding->heading_ascii = skip;
if (coding->eol_type != CODING_EOL_UNDECIDED)
{
- Lisp_Object tmp = Fget (val, Qeol_type);
+ Lisp_Object tmp;
+ tmp = Fget (val, Qeol_type);
if (VECTORP (tmp))
val = XVECTOR (tmp)->contents[coding->eol_type];
}
= encodep ? &coding->spec.ccl.encoder : &coding->spec.ccl.decoder;
int result;
+ if (encodep)
+ ccl->last_block = coding->mode & CODING_MODE_LAST_BLOCK;
+
coding->produced = ccl_driver (ccl, source, destination,
src_bytes, dst_bytes, &(coding->consumed));
if (encodep)
int len = to - from, len_byte = to_byte - from_byte;
int require, inserted, inserted_byte;
int head_skip, tail_skip, total_skip;
- Lisp_Object saved_coding_symbol = Qnil;
+ Lisp_Object saved_coding_symbol;
int multibyte = !NILP (current_buffer->enable_multibyte_characters);
int first = 1;
int fake_multibyte = 0;
unsigned char *src, *dst;
- Lisp_Object deletion = Qnil;
+ Lisp_Object deletion;
+
+ deletion = Qnil;
+ saved_coding_symbol = Qnil;
if (from < PT && PT < to)
SET_PT_BOTH (from, from_byte);
int from = 0, to = XSTRING (str)->size;
int to_byte = STRING_BYTES (XSTRING (str));
struct gcpro gcpro1;
- Lisp_Object saved_coding_symbol = Qnil;
+ Lisp_Object saved_coding_symbol;
int result;
+ saved_coding_symbol = Qnil;
if (encodep && !NILP (coding->pre_write_conversion)
|| !encodep && !NILP (coding->post_read_conversion))
{
if (encodep)
str = make_unibyte_string (buf, len + coding->produced);
else
- str = make_string_from_bytes (buf, len + coding->produced_char,
- len + coding->produced);
+ {
+ int chars= (coding->fake_multibyte
+ ? multibyte_chars_in_text (buf + from, coding->produced)
+ : coding->produced_char);
+ str = make_multibyte_string (buf, len + chars, len + coding->produced);
+ }
+
return str;
}
\f
#ifdef emacs
-/*** 7. Emacs Lisp library functions ***/
+/*** 8. Emacs Lisp library functions ***/
DEFUN ("coding-system-p", Fcoding_system_p, Scoding_system_p, 1, 1, 0,
"Return t if OBJECT is nil or a coding-system.\n\
coding_mask = detect_coding_mask (src, src_bytes, NULL, &dummy);
eol_type = detect_eol_type (src, src_bytes, &dummy);
if (eol_type == CODING_EOL_INCONSISTENT)
- eol_type == CODING_EOL_UNDECIDED;
+ eol_type = CODING_EOL_UNDECIDED;
if (!coding_mask)
{
if (VECTORP (val2))
val = XVECTOR (val2)->contents[eol_type];
}
- return val;
+ return (highest ? val : Fcons (val, Qnil));
}
/* At first, gather possible coding systems in VAL. */
"Detect coding system of the text in the region between START and END.\n\
Return a list of possible coding systems ordered by priority.\n\
\n\
-If only ASCII characters are found, it returns `undecided'\n\
-or its subsidiary coding system according to a detected end-of-line format.\n\
+If only ASCII characters are found, it returns a list of single element\n\
+`undecided' or its subsidiary coding system according to a detected\n\
+end-of-line format.\n\
\n\
If optional argument HIGHEST is non-nil, return the coding system of\n\
highest priority.")
"Detect coding system of the text in STRING.\n\
Return a list of possible coding systems ordered by priority.\n\
\n\
-If only ASCII characters are found, it returns `undecided'\n\
-or its subsidiary coding system according to a detected end-of-line format.\n\
+If only ASCII characters are found, it returns a list of single element\n\
+`undecided' or its subsidiary coding system according to a detected\n\
+end-of-line format.\n\
\n\
If optional argument HIGHEST is non-nil, return the coding system of\n\
highest priority.")
return code_convert_string1 (string, coding_system, nocopy, 1);
}
+/* Encode or decode STRING according to CODING_SYSTEM.
+ Do not set Vlast_coding_system_used. */
+
+Lisp_Object
+code_convert_string_norecord (string, coding_system, encodep)
+ Lisp_Object string, coding_system;
+ int encodep;
+{
+ struct coding_system coding;
+
+ CHECK_STRING (string, 0);
+ CHECK_SYMBOL (coding_system, 1);
+
+ if (NILP (coding_system))
+ return string;
+
+ if (setup_coding_system (Fcheck_coding_system (coding_system), &coding) < 0)
+ error ("Invalid coding system: %s", XSYMBOL (coding_system)->name->data);
+
+ coding.mode |= CODING_MODE_LAST_BLOCK;
+ return code_convert_string (string, &coding, encodep, Qt);
+}
\f
DEFUN ("decode-sjis-char", Fdecode_sjis_char, Sdecode_sjis_char, 1, 1, 0,
"Decode a JISX0208 character of shift-jis encoding.\n\
return Qnil;
}
-DEFUN ("update-iso-coding-systems", Fupdate_iso_coding_systems,
- Supdate_iso_coding_systems, 0, 0, 0,
- "Update internal database for ISO2022 based coding systems.\n\
+DEFUN ("update-coding-systems-internal", Fupdate_coding_systems_internal,
+ Supdate_coding_systems_internal, 0, 0, 0,
+ "Update internal database for ISO2022 and CCL based coding systems.\n\
When values of the following coding categories are changed, you must\n\
call this function:\n\
coding-category-iso-7, coding-category-iso-7-tight,\n\
coding-category-iso-8-1, coding-category-iso-8-2,\n\
- coding-category-iso-7-else, coding-category-iso-8-else")
+ coding-category-iso-7-else, coding-category-iso-8-else,\n\
+ coding-category-ccl")
()
{
int i;
- for (i = CODING_CATEGORY_IDX_ISO_7; i <= CODING_CATEGORY_IDX_ISO_8_ELSE;
- i++)
+ for (i = CODING_CATEGORY_IDX_ISO_7; i <= CODING_CATEGORY_IDX_CCL; i++)
{
- if (! coding_system_table[i])
- coding_system_table[i]
- = (struct coding_system *) xmalloc (sizeof (struct coding_system));
- setup_coding_system
- (XSYMBOL (XVECTOR (Vcoding_category_table)->contents[i])->value,
- coding_system_table[i]);
+ Lisp_Object val;
+
+ val = XSYMBOL (XVECTOR (Vcoding_category_table)->contents[i])->value;
+ if (!NILP (val))
+ {
+ if (! coding_system_table[i])
+ coding_system_table[i] = ((struct coding_system *)
+ xmalloc (sizeof (struct coding_system)));
+ setup_coding_system (val, coding_system_table[i]);
+ }
+ else if (coding_system_table[i])
+ {
+ xfree (coding_system_table[i]);
+ coding_system_table[i] = NULL;
+ }
}
+
return Qnil;
}
()
{
int i = 0, idx;
- Lisp_Object val = Vcoding_category_list;
+ Lisp_Object val;
+
+ val = Vcoding_category_list;
while (CONSP (val) && i < CODING_CATEGORY_IDX_MAX)
{
#endif /* emacs */
\f
-/*** 8. Post-amble ***/
+/*** 9. Post-amble ***/
+
+void
+init_coding ()
+{
+ conversion_buffer = (char *) xmalloc (MINIMUM_CONVERSION_BUFFER_SIZE);
+}
void
init_coding_once ()
iso_code_class[ISO_CODE_CSI] = ISO_control_sequence_introducer;
conversion_buffer_size = MINIMUM_CONVERSION_BUFFER_SIZE;
- conversion_buffer = (char *) xmalloc (MINIMUM_CONVERSION_BUFFER_SIZE);
setup_coding_system (Qnil, &keyboard_coding);
setup_coding_system (Qnil, &terminal_coding);
setup_coding_system (Qnil, &safe_terminal_coding);
+ setup_coding_system (Qnil, &default_buffer_file_coding);
bzero (coding_system_table, sizeof coding_system_table);
Qtranslation_table = intern ("translation-table");
staticpro (&Qtranslation_table);
- Fput (Qtranslation_table, Qchar_table_extra_slots, make_number (0));
+ Fput (Qtranslation_table, Qchar_table_extra_slots, make_number (1));
Qtranslation_table_id = intern ("translation-table-id");
staticpro (&Qtranslation_table_id);
Qsafe_charsets = intern ("safe-charsets");
staticpro (&Qsafe_charsets);
+ Qvalid_codes = intern ("valid-codes");
+ staticpro (&Qvalid_codes);
+
Qemacs_mule = intern ("emacs-mule");
staticpro (&Qemacs_mule);
defsubr (&Sset_keyboard_coding_system_internal);
defsubr (&Skeyboard_coding_system);
defsubr (&Sfind_operation_coding_system);
- defsubr (&Supdate_iso_coding_systems);
+ defsubr (&Supdate_coding_systems_internal);
defsubr (&Sset_coding_priority_internal);
DEFVAR_LISP ("coding-system-list", &Vcoding_system_list,
If VAL is a function symbol, the function must return a coding system\n\
or a cons of coding systems which are used as above.\n\
\n\
-See also the function `find-operation-coding-system'.");
+See also the function `find-operation-coding-system'\n\
+and the variable `auto-coding-alist'.");
Vfile_coding_system_alist = Qnil;
DEFVAR_LISP ("process-coding-system-alist", &Vprocess_coding_system_alist,
coding system which can encode the text in the case that a default\n\
coding system used in each operation can't encode the text.\n\
\n\
-The default value is `select-safe-codign-system' (which see).");
+The default value is `select-safe-coding-system' (which see).");
Vselect_safe_coding_system_function = Qnil;
}