#if 0
static int
-detect_coding_XXX (coding, detect_info)
- struct coding_system *coding;
- struct coding_detection_info *detect_info;
+detect_coding_XXX (struct coding_system *coding,
+ struct coding_detection_info *detect_info)
{
const unsigned char *src = coding->source;
const unsigned char *src_end = coding->source + coding->src_bytes;
while (1)
{
- /* Get one byte from the source. If the souce is exausted, jump
+ /* Get one byte from the source. If the source is exhausted, jump
to no_more_source:. */
ONE_MORE_BYTE (c);
return 0;
no_more_source:
- /* The source exausted successfully. */
+ /* The source exhausted successfully. */
detect_info->found |= found;
return 1;
}
#if 0
static void
-decode_coding_XXXX (coding)
- struct coding_system *coding;
+decode_coding_XXXX (struct coding_system *coding)
{
const unsigned char *src = coding->source + coding->consumed;
const unsigned char *src_end = coding->source + coding->src_bytes;
Below is a template of these functions. */
#if 0
static void
-encode_coding_XXX (coding)
- struct coding_system *coding;
+encode_coding_XXX (struct coding_system *coding)
{
int multibytep = coding->dst_multibyte;
int *charbuf = coding->charbuf;
Lisp_Object Qcoding_system, Qcoding_aliases, Qeol_type;
Lisp_Object Qunix, Qdos;
-extern Lisp_Object Qmac; /* frame.c */
Lisp_Object Qbuffer_file_coding_system;
Lisp_Object Qpost_read_conversion, Qpre_write_conversion;
Lisp_Object Qdefault_char;
Lisp_Object QCpost_read_conversion, QCpre_write_conversion;
Lisp_Object QCascii_compatible_p;
-extern Lisp_Object Qinsert_file_contents, Qwrite_region;
Lisp_Object Qcall_process, Qcall_process_region;
Lisp_Object Qstart_process, Qopen_network_stream;
Lisp_Object Qtarget_idx;
Lisp_Object Qinsufficient_source, Qinconsistent_eol, Qinvalid_source;
Lisp_Object Qinterrupted, Qinsufficient_memory;
-extern Lisp_Object Qcompletion_ignore_case;
-
/* If a symbol has this property, evaluate the value to define the
symbol as a coding system. */
static Lisp_Object Qcoding_system_define_form;
on output. */
#define CODING_ISO_FLAG_DESIGNATE_AT_BOL 0x0400
-/* If set, do not encode unsafe charactes on output. */
+/* If set, do not encode unsafe characters on output. */
#define CODING_ISO_FLAG_SAFE 0x0800
/* If set, extra latin codes (128..159) are accepted as a valid code
static Lisp_Object Vcoding_category_list;
/* Table of coding categories (Lisp symbols). This variable is for
- internal use oly. */
+ internal use only. */
static Lisp_Object Vcoding_category_table;
/* Table of coding-categories ordered by priority. */
} while (0)
-/* Like EMIT_ONE_ASCII_BYTE byt store two bytes; C1 and C2. */
+/* Like EMIT_ONE_ASCII_BYTE but store two bytes; C1 and C2. */
#define EMIT_TWO_ASCII_BYTES(c1, c2) \
do { \
/* Prototypes for static functions. */
-static void record_conversion_result P_ ((struct coding_system *coding,
- enum coding_result_code result));
-static int detect_coding_utf_8 P_ ((struct coding_system *,
- struct coding_detection_info *info));
-static void decode_coding_utf_8 P_ ((struct coding_system *));
-static int encode_coding_utf_8 P_ ((struct coding_system *));
-
-static int detect_coding_utf_16 P_ ((struct coding_system *,
- struct coding_detection_info *info));
-static void decode_coding_utf_16 P_ ((struct coding_system *));
-static int encode_coding_utf_16 P_ ((struct coding_system *));
-
-static int detect_coding_iso_2022 P_ ((struct coding_system *,
- struct coding_detection_info *info));
-static void decode_coding_iso_2022 P_ ((struct coding_system *));
-static int encode_coding_iso_2022 P_ ((struct coding_system *));
-
-static int detect_coding_emacs_mule P_ ((struct coding_system *,
- struct coding_detection_info *info));
-static void decode_coding_emacs_mule P_ ((struct coding_system *));
-static int encode_coding_emacs_mule P_ ((struct coding_system *));
-
-static int detect_coding_sjis P_ ((struct coding_system *,
- struct coding_detection_info *info));
-static void decode_coding_sjis P_ ((struct coding_system *));
-static int encode_coding_sjis P_ ((struct coding_system *));
-
-static int detect_coding_big5 P_ ((struct coding_system *,
- struct coding_detection_info *info));
-static void decode_coding_big5 P_ ((struct coding_system *));
-static int encode_coding_big5 P_ ((struct coding_system *));
-
-static int detect_coding_ccl P_ ((struct coding_system *,
- struct coding_detection_info *info));
-static void decode_coding_ccl P_ ((struct coding_system *));
-static int encode_coding_ccl P_ ((struct coding_system *));
-
-static void decode_coding_raw_text P_ ((struct coding_system *));
-static int encode_coding_raw_text P_ ((struct coding_system *));
-
-static void coding_set_source P_ ((struct coding_system *));
-static void coding_set_destination P_ ((struct coding_system *));
-static void coding_alloc_by_realloc P_ ((struct coding_system *, EMACS_INT));
-static void coding_alloc_by_making_gap P_ ((struct coding_system *,
- EMACS_INT, EMACS_INT));
-static unsigned char *alloc_destination P_ ((struct coding_system *,
- EMACS_INT, unsigned char *));
-static void setup_iso_safe_charsets P_ ((Lisp_Object));
-static unsigned char *encode_designation_at_bol P_ ((struct coding_system *,
- int *, int *,
- unsigned char *));
-static int detect_eol P_ ((const unsigned char *,
- EMACS_INT, enum coding_category));
-static Lisp_Object adjust_coding_eol_type P_ ((struct coding_system *, int));
-static void decode_eol P_ ((struct coding_system *));
-static Lisp_Object get_translation_table P_ ((Lisp_Object, int, int *));
-static Lisp_Object get_translation P_ ((Lisp_Object, int *, int *));
-static int produce_chars P_ ((struct coding_system *, Lisp_Object, int));
-static INLINE void produce_charset P_ ((struct coding_system *, int *,
- EMACS_INT));
-static void produce_annotation P_ ((struct coding_system *, EMACS_INT));
-static int decode_coding P_ ((struct coding_system *));
-static INLINE int *handle_composition_annotation P_ ((EMACS_INT, EMACS_INT,
- struct coding_system *,
- int *, EMACS_INT *));
-static INLINE int *handle_charset_annotation P_ ((EMACS_INT, EMACS_INT,
- struct coding_system *,
- int *, EMACS_INT *));
-static void consume_chars P_ ((struct coding_system *, Lisp_Object, int));
-static int encode_coding P_ ((struct coding_system *));
-static Lisp_Object make_conversion_work_buffer P_ ((int));
-static Lisp_Object code_conversion_restore P_ ((Lisp_Object));
-static INLINE int char_encodable_p P_ ((int, Lisp_Object));
-static Lisp_Object make_subsidiaries P_ ((Lisp_Object));
+static void record_conversion_result (struct coding_system *coding,
+ enum coding_result_code result);
+static int detect_coding_utf_8 (struct coding_system *,
+ struct coding_detection_info *info);
+static void decode_coding_utf_8 (struct coding_system *);
+static int encode_coding_utf_8 (struct coding_system *);
+
+static int detect_coding_utf_16 (struct coding_system *,
+ struct coding_detection_info *info);
+static void decode_coding_utf_16 (struct coding_system *);
+static int encode_coding_utf_16 (struct coding_system *);
+
+static int detect_coding_iso_2022 (struct coding_system *,
+ struct coding_detection_info *info);
+static void decode_coding_iso_2022 (struct coding_system *);
+static int encode_coding_iso_2022 (struct coding_system *);
+
+static int detect_coding_emacs_mule (struct coding_system *,
+ struct coding_detection_info *info);
+static void decode_coding_emacs_mule (struct coding_system *);
+static int encode_coding_emacs_mule (struct coding_system *);
+
+static int detect_coding_sjis (struct coding_system *,
+ struct coding_detection_info *info);
+static void decode_coding_sjis (struct coding_system *);
+static int encode_coding_sjis (struct coding_system *);
+
+static int detect_coding_big5 (struct coding_system *,
+ struct coding_detection_info *info);
+static void decode_coding_big5 (struct coding_system *);
+static int encode_coding_big5 (struct coding_system *);
+
+static int detect_coding_ccl (struct coding_system *,
+ struct coding_detection_info *info);
+static void decode_coding_ccl (struct coding_system *);
+static int encode_coding_ccl (struct coding_system *);
+
+static void decode_coding_raw_text (struct coding_system *);
+static int encode_coding_raw_text (struct coding_system *);
+
+static void coding_set_source (struct coding_system *);
+static void coding_set_destination (struct coding_system *);
+static void coding_alloc_by_realloc (struct coding_system *, EMACS_INT);
+static void coding_alloc_by_making_gap (struct coding_system *,
+ EMACS_INT, EMACS_INT);
+static unsigned char *alloc_destination (struct coding_system *,
+ EMACS_INT, unsigned char *);
+static void setup_iso_safe_charsets (Lisp_Object);
+static unsigned char *encode_designation_at_bol (struct coding_system *,
+ int *, int *,
+ unsigned char *);
+static int detect_eol (const unsigned char *,
+ EMACS_INT, enum coding_category);
+static Lisp_Object adjust_coding_eol_type (struct coding_system *, int);
+static void decode_eol (struct coding_system *);
+static Lisp_Object get_translation_table (Lisp_Object, int, int *);
+static Lisp_Object get_translation (Lisp_Object, int *, int *);
+static int produce_chars (struct coding_system *, Lisp_Object, int);
+static INLINE void produce_charset (struct coding_system *, int *,
+ EMACS_INT);
+static void produce_annotation (struct coding_system *, EMACS_INT);
+static int decode_coding (struct coding_system *);
+static INLINE int *handle_composition_annotation (EMACS_INT, EMACS_INT,
+ struct coding_system *,
+ int *, EMACS_INT *);
+static INLINE int *handle_charset_annotation (EMACS_INT, EMACS_INT,
+ struct coding_system *,
+ int *, EMACS_INT *);
+static void consume_chars (struct coding_system *, Lisp_Object, int);
+static int encode_coding (struct coding_system *);
+static Lisp_Object make_conversion_work_buffer (int);
+static Lisp_Object code_conversion_restore (Lisp_Object);
+static INLINE int char_encodable_p (int, Lisp_Object);
+static Lisp_Object make_subsidiaries (Lisp_Object);
static void
record_conversion_result (struct coding_system *coding,
static void
-coding_set_source (coding)
- struct coding_system *coding;
+coding_set_source (struct coding_system *coding)
{
if (BUFFERP (coding->src_object))
{
}
static void
-coding_set_destination (coding)
- struct coding_system *coding;
+coding_set_destination (struct coding_system *coding)
{
if (BUFFERP (coding->dst_object))
{
static void
-coding_alloc_by_realloc (coding, bytes)
- struct coding_system *coding;
- EMACS_INT bytes;
+coding_alloc_by_realloc (struct coding_system *coding, EMACS_INT bytes)
{
coding->destination = (unsigned char *) xrealloc (coding->destination,
coding->dst_bytes + bytes);
}
static void
-coding_alloc_by_making_gap (coding, gap_head_used, bytes)
- struct coding_system *coding;
- EMACS_INT gap_head_used, bytes;
+coding_alloc_by_making_gap (struct coding_system *coding,
+ EMACS_INT gap_head_used, EMACS_INT bytes)
{
if (EQ (coding->src_object, coding->dst_object))
{
static unsigned char *
-alloc_destination (coding, nbytes, dst)
- struct coding_system *coding;
- EMACS_INT nbytes;
- unsigned char *dst;
+alloc_destination (struct coding_system *coding, EMACS_INT nbytes,
+ unsigned char *dst)
{
EMACS_INT offset = dst - coding->destination;
METHOD is one of enum composition_method.
- Optionnal COMPOSITION-COMPONENTS are characters and composition
+ Optional COMPOSITION-COMPONENTS are characters and composition
rules.
In the case of CODING_ANNOTATE_CHARSET_MASK, one element CHARSET-ID
#define UTF_8_BOM_3 0xBF
static int
-detect_coding_utf_8 (coding, detect_info)
- struct coding_system *coding;
- struct coding_detection_info *detect_info;
+detect_coding_utf_8 (struct coding_system *coding,
+ struct coding_detection_info *detect_info)
{
const unsigned char *src = coding->source, *src_base;
const unsigned char *src_end = coding->source + coding->src_bytes;
static void
-decode_coding_utf_8 (coding)
- struct coding_system *coding;
+decode_coding_utf_8 (struct coding_system *coding)
{
const unsigned char *src = coding->source + coding->consumed;
const unsigned char *src_end = coding->source + coding->src_bytes;
}
CODING_UTF_8_BOM (coding) = utf_without_bom;
-
-
while (1)
{
int c, c1, c2, c3, c4, c5;
{
c = - c1;
}
- else if (UTF_8_1_OCTET_P(c1))
+ else if (UTF_8_1_OCTET_P (c1))
{
if (eol_crlf && c1 == '\r')
ONE_MORE_BYTE (byte_after_cr);
static int
-encode_coding_utf_8 (coding)
- struct coding_system *coding;
+encode_coding_utf_8 (struct coding_system *coding)
{
int multibytep = coding->dst_multibyte;
int *charbuf = coding->charbuf;
static int
-detect_coding_utf_16 (coding, detect_info)
- struct coding_system *coding;
- struct coding_detection_info *detect_info;
+detect_coding_utf_16 (struct coding_system *coding,
+ struct coding_detection_info *detect_info)
{
const unsigned char *src = coding->source, *src_base = src;
const unsigned char *src_end = coding->source + coding->src_bytes;
}
static void
-decode_coding_utf_16 (coding)
- struct coding_system *coding;
+decode_coding_utf_16 (struct coding_system *coding)
{
const unsigned char *src = coding->source + coding->consumed;
const unsigned char *src_end = coding->source + coding->src_bytes;
}
static int
-encode_coding_utf_16 (coding)
- struct coding_system *coding;
+encode_coding_utf_16 (struct coding_system *coding)
{
int multibytep = coding->dst_multibyte;
int *charbuf = coding->charbuf;
CHARS is 0xA0 plus a number of characters composed by this
data,
- COMPONENTs are characters of multibye form or composition
+ 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
else return 0. */
static int
-detect_coding_emacs_mule (coding, detect_info)
- struct coding_system *coding;
- struct coding_detection_info *detect_info;
+detect_coding_emacs_mule (struct coding_system *coding,
+ struct coding_detection_info *detect_info)
{
const unsigned char *src = coding->source, *src_base;
const unsigned char *src_end = coding->source + coding->src_bytes;
}
else
{
- int more_bytes = emacs_mule_bytes[*src_base] - 1;
+ int more_bytes = emacs_mule_bytes[c] - 1;
while (more_bytes > 0)
{
-1. If SRC is too short, return -2. */
int
-emacs_mule_char (coding, src, nbytes, nchars, id, cmp_status)
- struct coding_system *coding;
- const unsigned char *src;
- int *nbytes, *nchars, *id;
- struct composition_status *cmp_status;
+emacs_mule_char (struct coding_system *coding, const unsigned char *src,
+ int *nbytes, int *nchars, int *id,
+ struct composition_status *cmp_status)
{
const unsigned char *src_end = coding->source + coding->src_bytes;
const unsigned char *src_base = src;
(3) alt&rule composition: 0x80 0xF5 BYTES CHARS | ALT RULE ... ALT CHAR ...
and these old form:
-
+
(4) relative composition: 0x80 | MSEQ ... MSEQ
(5) rulebase composition: 0x80 0xFF | MSEQ MRULE ... MSEQ
static int
-emacs_mule_finish_composition (charbuf, cmp_status)
- int *charbuf;
- struct composition_status *cmp_status;
+emacs_mule_finish_composition (int *charbuf,
+ struct composition_status *cmp_status)
{
int idx = - cmp_status->length;
int new_chars;
static void
-decode_coding_emacs_mule (coding)
- struct coding_system *coding;
+decode_coding_emacs_mule (struct coding_system *coding)
{
const unsigned char *src = coding->source + coding->consumed;
const unsigned char *src_end = coding->source + coding->src_bytes;
const unsigned char *src_base;
int *charbuf = coding->charbuf + coding->charbuf_used;
- /* We may produce two annocations (charset and composition) in one
- loop and one more charset annocation at the end. */
+ /* We may produce two annotations (charset and composition) in one
+ loop and one more charset annotation at the end. */
int *charbuf_end
= coding->charbuf + coding->charbuf_size - (MAX_ANNOTATION_LENGTH * 3);
int consumed_chars = 0, consumed_chars_base;
/* emacs_mule_char can load a charset map from a file, which
allocates a large structure and might cause buffer text
to be relocated as result. Thus, we need to remember the
- original pointer to buffer text, and fixup all related
+ original pointer to buffer text, and fix up all related
pointers after the call. */
const unsigned char *orig = coding->source;
EMACS_INT offset;
cmp_status->ncomps -= nchars;
}
- /* Now if C >= 0, we found a normally encoded characer, if C <
+ /* Now if C >= 0, we found a normally encoded character, if C <
0, we found an old-style composition component character or
rule. */
static int
-encode_coding_emacs_mule (coding)
- struct coding_system *coding;
+encode_coding_emacs_mule (struct coding_system *coding)
{
int multibytep = coding->dst_multibyte;
int *charbuf = coding->charbuf;
(CODING_ISO_INITIAL (&coding_categories[category], 1) >= 0)
static void
-setup_iso_safe_charsets (attrs)
- Lisp_Object attrs;
+setup_iso_safe_charsets (Lisp_Object attrs)
{
Lisp_Object charset_list, safe_charsets;
Lisp_Object request;
/* See the above "GENERAL NOTES on `detect_coding_XXX ()' functions".
- Check if a text is encoded in one of ISO-2022 based codig systems.
+ Check if a text is encoded in one of ISO-2022 based coding systems.
If it is, return 1, else return 0. */
static int
-detect_coding_iso_2022 (coding, detect_info)
- struct coding_system *coding;
- struct coding_detection_info *detect_info;
+detect_coding_iso_2022 (struct coding_system *coding,
+ struct coding_detection_info *detect_info)
{
const unsigned char *src = coding->source, *src_base = src;
const unsigned char *src_end = coding->source + coding->src_bytes;
/* Finish the current composition as invalid. */
-static int finish_composition P_ ((int *, struct composition_status *));
+static int finish_composition (int *, struct composition_status *);
static int
-finish_composition (charbuf, cmp_status)
- int *charbuf;
- struct composition_status *cmp_status;
+finish_composition (int *charbuf, struct composition_status *cmp_status)
{
int idx = - cmp_status->length;
int new_chars;
return new_chars;
}
-/* If characers are under composition, finish the composition. */
+/* If characters are under composition, finish the composition. */
#define MAYBE_FINISH_COMPOSITION() \
do { \
if (cmp_status->state != COMPOSING_NO) \
/* See the above "GENERAL NOTES on `decode_coding_XXX ()' functions". */
static void
-decode_coding_iso_2022 (coding)
- struct coding_system *coding;
+decode_coding_iso_2022 (struct coding_system *coding)
{
const unsigned char *src = coding->source + coding->consumed;
const unsigned char *src_end = coding->source + coding->src_bytes;
const unsigned char *src_base;
int *charbuf = coding->charbuf + coding->charbuf_used;
- /* We may produce two annocations (charset and composition) in one
- loop and one more charset annocation at the end. */
+ /* We may produce two annotations (charset and composition) in one
+ loop and one more charset annotation at the end. */
int *charbuf_end
= coding->charbuf + coding->charbuf_size - (MAX_ANNOTATION_LENGTH * 3);
int consumed_chars = 0, consumed_chars_base;
goto 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)
{
int size;
ONE_MORE_BYTE (dim);
- if (dim < 0 || dim > 4)
+ if (dim < '0' || dim > '4')
goto invalid_code;
ONE_MORE_BYTE (M);
if (M < 128)
#define ENCODE_DESIGNATION(charset, reg, coding) \
do { \
unsigned char final_char = CHARSET_ISO_FINAL (charset); \
- char *intermediate_char_94 = "()*+"; \
- char *intermediate_char_96 = ",-./"; \
+ const char *intermediate_char_94 = "()*+"; \
+ const char *intermediate_char_96 = ",-./"; \
int revision = -1; \
int c; \
\
#define ENCODE_ISO_CHARACTER(charset, c) \
do { \
- int code = ENCODE_CHAR ((charset),(c)); \
+ int code = ENCODE_CHAR ((charset), (c)); \
\
if (CHARSET_DIMENSION (charset) == 1) \
ENCODE_ISO_CHARACTER_DIMENSION1 ((charset), code); \
Return new DST. */
unsigned char *
-encode_invocation_designation (charset, coding, dst, p_nchars)
- struct charset *charset;
- struct coding_system *coding;
- unsigned char *dst;
- int *p_nchars;
+encode_invocation_designation (struct charset *charset,
+ struct coding_system *coding,
+ unsigned char *dst, int *p_nchars)
{
int multibytep = coding->dst_multibyte;
int produced_chars = *p_nchars;
find all the necessary designations. */
static unsigned char *
-encode_designation_at_bol (coding, charbuf, charbuf_end, dst)
- struct coding_system *coding;
- int *charbuf, *charbuf_end;
- unsigned char *dst;
+encode_designation_at_bol (struct coding_system *coding, int *charbuf,
+ int *charbuf_end, unsigned char *dst)
{
struct charset *charset;
/* Table of charsets to be designated to each graphic register. */
/* See the above "GENERAL NOTES on `encode_coding_XXX ()' functions". */
static int
-encode_coding_iso_2022 (coding)
- struct coding_system *coding;
+encode_coding_iso_2022 (struct coding_system *coding)
{
int multibytep = coding->dst_multibyte;
int *charbuf = coding->charbuf;
charset_list = CODING_ATTR_CHARSET_LIST (attrs);
coding->safe_charsets = SDATA (CODING_ATTR_SAFE_CHARSETS (attrs));
- ascii_compatible = ! NILP (CODING_ATTR_ASCII_COMPAT (attrs));
+ ascii_compatible
+ = (! NILP (CODING_ATTR_ASCII_COMPAT (attrs))
+ && ! (CODING_ISO_FLAGS (coding) & (CODING_ISO_FLAG_DESIGNATION
+ | CODING_ISO_FLAG_LOCKING_SHIFT)));
while (charbuf < charbuf_end)
{
CATEGORY_MASK_SJIS, else return 0. */
static int
-detect_coding_sjis (coding, detect_info)
- struct coding_system *coding;
- struct coding_detection_info *detect_info;
+detect_coding_sjis (struct coding_system *coding,
+ struct coding_detection_info *detect_info)
{
const unsigned char *src = coding->source, *src_base;
const unsigned char *src_end = coding->source + coding->src_bytes;
CATEGORY_MASK_BIG5, else return 0. */
static int
-detect_coding_big5 (coding, detect_info)
- struct coding_system *coding;
- struct coding_detection_info *detect_info;
+detect_coding_big5 (struct coding_system *coding,
+ struct coding_detection_info *detect_info)
{
const unsigned char *src = coding->source, *src_base;
const unsigned char *src_end = coding->source + coding->src_bytes;
If SJIS_P is 1, decode SJIS text, else decode BIG5 test. */
static void
-decode_coding_sjis (coding)
- struct coding_system *coding;
+decode_coding_sjis (struct coding_system *coding)
{
const unsigned char *src = coding->source + coding->consumed;
const unsigned char *src_end = coding->source + coding->src_bytes;
const unsigned char *src_base;
int *charbuf = coding->charbuf + coding->charbuf_used;
- /* We may produce one charset annocation in one loop and one more at
+ /* We may produce one charset annotation in one loop and one more at
the end. */
int *charbuf_end
= coding->charbuf + coding->charbuf_size - (MAX_ANNOTATION_LENGTH * 2);
}
static void
-decode_coding_big5 (coding)
- struct coding_system *coding;
+decode_coding_big5 (struct coding_system *coding)
{
const unsigned char *src = coding->source + coding->consumed;
const unsigned char *src_end = coding->source + coding->src_bytes;
const unsigned char *src_base;
int *charbuf = coding->charbuf + coding->charbuf_used;
- /* We may produce one charset annocation in one loop and one more at
+ /* We may produce one charset annotation in one loop and one more at
the end. */
int *charbuf_end
= coding->charbuf + coding->charbuf_size - (MAX_ANNOTATION_LENGTH * 2);
SJIS text, else encode BIG5 text. */
static int
-encode_coding_sjis (coding)
- struct coding_system *coding;
+encode_coding_sjis (struct coding_system *coding)
{
int multibytep = coding->dst_multibyte;
int *charbuf = coding->charbuf;
}
static int
-encode_coding_big5 (coding)
- struct coding_system *coding;
+encode_coding_big5 (struct coding_system *coding)
{
int multibytep = coding->dst_multibyte;
int *charbuf = coding->charbuf;
CATEGORY_MASK_CCL, else return 0. */
static int
-detect_coding_ccl (coding, detect_info)
- struct coding_system *coding;
- struct coding_detection_info *detect_info;
+detect_coding_ccl (struct coding_system *coding,
+ struct coding_detection_info *detect_info)
{
const unsigned char *src = coding->source, *src_base;
const unsigned char *src_end = coding->source + coding->src_bytes;
}
static void
-decode_coding_ccl (coding)
- struct coding_system *coding;
+decode_coding_ccl (struct coding_system *coding)
{
const unsigned char *src = coding->source + coding->consumed;
const unsigned char *src_end = coding->source + coding->src_bytes;
}
static int
-encode_coding_ccl (coding)
- struct coding_system *coding;
+encode_coding_ccl (struct coding_system *coding)
{
- struct ccl_program ccl;
+ struct ccl_program *ccl = &coding->spec.ccl->ccl;
int multibytep = coding->dst_multibyte;
int *charbuf = coding->charbuf;
int *charbuf_end = charbuf + coding->charbuf_used;
Lisp_Object attrs, charset_list;
CODING_GET_INFO (coding, attrs, charset_list);
- setup_ccl_program (&ccl, CODING_CCL_ENCODER (coding));
-
- ccl.last_block = coding->mode & CODING_MODE_LAST_BLOCK;
- ccl.dst_multibyte = coding->dst_multibyte;
+ if (coding->consumed_char == coding->src_chars
+ && coding->mode & CODING_MODE_LAST_BLOCK)
+ ccl->last_block = 1;
while (charbuf < charbuf_end)
{
- ccl_driver (&ccl, charbuf, destination_charbuf,
+ ccl_driver (ccl, charbuf, destination_charbuf,
charbuf_end - charbuf, 1024, charset_list);
if (multibytep)
{
- ASSURE_DESTINATION (ccl.produced * 2);
- for (i = 0; i < ccl.produced; i++)
+ ASSURE_DESTINATION (ccl->produced * 2);
+ for (i = 0; i < ccl->produced; i++)
EMIT_ONE_BYTE (destination_charbuf[i] & 0xFF);
}
else
{
- ASSURE_DESTINATION (ccl.produced);
- for (i = 0; i < ccl.produced; i++)
+ ASSURE_DESTINATION (ccl->produced);
+ for (i = 0; i < ccl->produced; i++)
*dst++ = destination_charbuf[i] & 0xFF;
- produced_chars += ccl.produced;
+ produced_chars += ccl->produced;
}
- charbuf += ccl.consumed;
- if (ccl.status == CCL_STAT_QUIT
- || ccl.status == CCL_STAT_INVALID_CMD)
+ charbuf += ccl->consumed;
+ if (ccl->status == CCL_STAT_QUIT
+ || ccl->status == CCL_STAT_INVALID_CMD)
break;
}
- switch (ccl.status)
+ switch (ccl->status)
{
case CCL_STAT_SUSPEND_BY_SRC:
record_conversion_result (coding, CODING_RESULT_INSUFFICIENT_SRC);
/* See the above "GENERAL NOTES on `decode_coding_XXX ()' functions". */
static void
-decode_coding_raw_text (coding)
- struct coding_system *coding;
+decode_coding_raw_text (struct coding_system *coding)
{
int eol_crlf =
!inhibit_eol_conversion && EQ (CODING_ID_EOL_TYPE (coding->id), Qdos);
}
static int
-encode_coding_raw_text (coding)
- struct coding_system *coding;
+encode_coding_raw_text (struct coding_system *coding)
{
int multibytep = coding->dst_multibyte;
int *charbuf = coding->charbuf;
is, return 1, else return 0. */
static int
-detect_coding_charset (coding, detect_info)
- struct coding_system *coding;
- struct coding_detection_info *detect_info;
+detect_coding_charset (struct coding_system *coding,
+ struct coding_detection_info *detect_info)
{
const unsigned char *src = coding->source, *src_base;
const unsigned char *src_end = coding->source + coding->src_bytes;
}
static void
-decode_coding_charset (coding)
- struct coding_system *coding;
+decode_coding_charset (struct coding_system *coding)
{
const unsigned char *src = coding->source + coding->consumed;
const unsigned char *src_end = coding->source + coding->src_bytes;
const unsigned char *src_base;
int *charbuf = coding->charbuf + coding->charbuf_used;
- /* We may produce one charset annocation in one loop and one more at
+ /* We may produce one charset annotation in one loop and one more at
the end. */
int *charbuf_end
= coding->charbuf + coding->charbuf_size - (MAX_ANNOTATION_LENGTH * 2);
}
static int
-encode_coding_charset (coding)
- struct coding_system *coding;
+encode_coding_charset (struct coding_system *coding)
{
int multibytep = coding->dst_multibyte;
int *charbuf = coding->charbuf;
CODING_SYSTEM is invalid, signal an error. */
void
-setup_coding_system (coding_system, coding)
- Lisp_Object coding_system;
- struct coding_system *coding;
+setup_coding_system (Lisp_Object coding_system, struct coding_system *coding)
{
Lisp_Object attrs;
Lisp_Object eol_type;
/* Return a list of charsets supported by CODING. */
Lisp_Object
-coding_charset_list (coding)
- struct coding_system *coding;
+coding_charset_list (struct coding_system *coding)
{
Lisp_Object attrs, charset_list;
/* Return a list of charsets supported by CODING-SYSTEM. */
Lisp_Object
-coding_system_charset_list (coding_system)
- Lisp_Object coding_system;
+coding_system_charset_list (Lisp_Object coding_system)
{
int id;
Lisp_Object attrs, charset_list;
eol_type as CODING-SYSTEM. */
Lisp_Object
-raw_text_coding_system (coding_system)
- Lisp_Object coding_system;
+raw_text_coding_system (Lisp_Object coding_system)
{
Lisp_Object spec, attrs;
Lisp_Object eol_type, raw_text_eol_type;
}
-/* If CODING_SYSTEM doesn't specify end-of-line format but PARENT
- does, return one of the subsidiary that has the same eol-spec as
- PARENT. Otherwise, return CODING_SYSTEM. If PARENT is nil,
- inherit end-of-line format from the system's setting
+/* If CODING_SYSTEM doesn't specify end-of-line format, return one of
+ the subsidiary that has the same eol-spec as PARENT (if it is not
+ nil and specifies end-of-line format) or the system's setting
(system_eol_type). */
Lisp_Object
-coding_inherit_eol_type (coding_system, parent)
- Lisp_Object coding_system, parent;
+coding_inherit_eol_type (Lisp_Object coding_system, Lisp_Object parent)
{
Lisp_Object spec, eol_type;
parent_spec = CODING_SYSTEM_SPEC (parent);
parent_eol_type = AREF (parent_spec, 2);
+ if (VECTORP (parent_eol_type))
+ parent_eol_type = system_eol_type;
}
else
parent_eol_type = system_eol_type;
return coding_system;
}
+
+/* Check if text-conversion and eol-conversion of CODING_SYSTEM are
+ decided for writing to a process. If not, complement them, and
+ return a new coding system. */
+
+Lisp_Object
+complement_process_encoding_system (Lisp_Object coding_system)
+{
+ Lisp_Object coding_base = Qnil, eol_base = Qnil;
+ Lisp_Object spec, attrs;
+ int i;
+
+ for (i = 0; i < 3; i++)
+ {
+ if (i == 1)
+ coding_system = CDR_SAFE (Vdefault_process_coding_system);
+ else if (i == 2)
+ coding_system = preferred_coding_system ();
+ spec = CODING_SYSTEM_SPEC (coding_system);
+ if (NILP (spec))
+ continue;
+ attrs = AREF (spec, 0);
+ if (NILP (coding_base) && ! EQ (CODING_ATTR_TYPE (attrs), Qundecided))
+ coding_base = CODING_ATTR_BASE_NAME (attrs);
+ if (NILP (eol_base) && ! VECTORP (AREF (spec, 2)))
+ eol_base = coding_system;
+ if (! NILP (coding_base) && ! NILP (eol_base))
+ break;
+ }
+
+ if (i > 0)
+ /* The original CODING_SYSTEM didn't specify text-conversion or
+ eol-conversion. Be sure that we return a fully complemented
+ coding system. */
+ coding_system = coding_inherit_eol_type (coding_base, eol_base);
+ return coding_system;
+}
+
+
/* 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
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.
#define MAX_EOL_CHECK_COUNT 3
static int
-detect_eol (source, src_bytes, category)
- const unsigned char *source;
- EMACS_INT src_bytes;
- enum coding_category category;
+detect_eol (const unsigned char *source, EMACS_INT src_bytes,
+ enum coding_category category)
{
const unsigned char *src = source, *src_end = src + src_bytes;
unsigned char c;
static Lisp_Object
-adjust_coding_eol_type (coding, eol_seen)
- struct coding_system *coding;
- int eol_seen;
+adjust_coding_eol_type (struct coding_system *coding, int eol_seen)
{
Lisp_Object eol_type;
system. */
void
-detect_coding (coding)
- struct coding_system *coding;
+detect_coding (struct coding_system *coding)
{
const unsigned char *src, *src_end;
int saved_mode = coding->mode;
{
/* We didn't find an 8-bit code. We may
have found a null-byte, but it's very
- rare that a binary file confirm to
+ rare that a binary file conforms to
ISO-2022. */
src = src_end;
coding->head_ascii = src - coding->source;
static void
-decode_eol (coding)
- struct coding_system *coding;
+decode_eol (struct coding_system *coding)
{
Lisp_Object eol_type;
unsigned char *p, *pbeg, *pend;
for (p = pend - 2; p >= pbeg; p--)
if (*p == '\r')
{
- safe_bcopy ((char *) (p + 1), (char *) p, pend-- - p - 1);
+ memmove (p, p + 1, pend-- - p - 1);
n++;
}
}
decoding (ENCODEP is zero). */
static Lisp_Object
-get_translation_table (attrs, encodep, max_lookup)
- Lisp_Object attrs;
- int encodep, *max_lookup;
+get_translation_table (Lisp_Object attrs, int encodep, int *max_lookup)
{
Lisp_Object standard, translation_table;
Lisp_Object val;
If BUF is too short to lookup characters in FROM, return Qt. */
static Lisp_Object
-get_translation (trans, buf, buf_end)
- Lisp_Object trans;
- int *buf, *buf_end;
+get_translation (Lisp_Object trans, int *buf, int *buf_end)
{
if (INTEGERP (trans))
static int
-produce_chars (coding, translation_table, last_block)
- struct coding_system *coding;
- Lisp_Object translation_table;
- int last_block;
+produce_chars (struct coding_system *coding, Lisp_Object translation_table,
+ int last_block)
{
unsigned char *dst = coding->destination + coding->produced;
unsigned char *dst_end = coding->destination + coding->dst_bytes;
*/
static INLINE void
-produce_composition (coding, charbuf, pos)
- struct coding_system *coding;
- int *charbuf;
- EMACS_INT pos;
+produce_composition (struct coding_system *coding, int *charbuf, EMACS_INT pos)
{
int len;
EMACS_INT to;
*/
static INLINE void
-produce_charset (coding, charbuf, pos)
- struct coding_system *coding;
- int *charbuf;
- EMACS_INT pos;
+produce_charset (struct coding_system *coding, int *charbuf, EMACS_INT pos)
{
EMACS_INT from = pos - charbuf[2];
struct charset *charset = CHARSET_FROM_ID (charbuf[3]);
static void
-produce_annotation (coding, pos)
- struct coding_system *coding;
- EMACS_INT pos;
+produce_annotation (struct coding_system *coding, EMACS_INT pos)
{
int *charbuf = coding->charbuf;
int *charbuf_end = charbuf + coding->charbuf_used;
*/
static int
-decode_coding (coding)
- struct coding_system *coding;
+decode_coding (struct coding_system *coding)
{
Lisp_Object attrs;
Lisp_Object undo_list;
return BUF. */
static INLINE int *
-handle_composition_annotation (pos, limit, coding, buf, stop)
- EMACS_INT pos, limit;
- struct coding_system *coding;
- int *buf;
- EMACS_INT *stop;
+handle_composition_annotation (EMACS_INT pos, EMACS_INT limit,
+ struct coding_system *coding, int *buf,
+ EMACS_INT *stop)
{
EMACS_INT start, end;
Lisp_Object prop;
property value is non-nil (limiting by LIMIT), and return BUF. */
static INLINE int *
-handle_charset_annotation (pos, limit, coding, buf, stop)
- EMACS_INT pos, limit;
- struct coding_system *coding;
- int *buf;
- EMACS_INT *stop;
+handle_charset_annotation (EMACS_INT pos, EMACS_INT limit,
+ struct coding_system *coding, int *buf,
+ EMACS_INT *stop)
{
Lisp_Object val, next;
int id;
static void
-consume_chars (coding, translation_table, max_lookup)
- struct coding_system *coding;
- Lisp_Object translation_table;
- int max_lookup;
+consume_chars (struct coding_system *coding, Lisp_Object translation_table,
+ int max_lookup)
{
int *buf = coding->charbuf;
int *buf_end = coding->charbuf + coding->charbuf_size;
memory area specified by CODING->destination. */
static int
-encode_coding (coding)
- struct coding_system *coding;
+encode_coding (struct coding_system *coding)
{
Lisp_Object attrs;
Lisp_Object translation_table;
int max_lookup;
+ struct ccl_spec cclspec;
attrs = CODING_ID_ATTRS (coding->id);
if (coding->encoder == encode_coding_raw_text)
ALLOC_CONVERSION_WORK_AREA (coding);
+ if (coding->encoder == encode_coding_ccl)
+ {
+ coding->spec.ccl = &cclspec;
+ setup_ccl_program (&cclspec.ccl, CODING_CCL_ENCODER (coding));
+ }
do {
coding_set_source (coding);
consume_chars (coding, translation_table, max_lookup);
static int reused_workbuf_in_use;
-/* Return a working buffer of code convesion. MULTIBYTE specifies the
+/* Return a working buffer of code conversion. MULTIBYTE specifies the
multibyteness of returning buffer. */
static Lisp_Object
-make_conversion_work_buffer (multibyte)
- int multibyte;
+make_conversion_work_buffer (int multibyte)
{
Lisp_Object name, workbuf;
struct buffer *current;
static Lisp_Object
-code_conversion_restore (arg)
- Lisp_Object arg;
+code_conversion_restore (Lisp_Object arg)
{
Lisp_Object current, workbuf;
struct gcpro gcpro1;
}
Lisp_Object
-code_conversion_save (with_work_buf, multibyte)
- int with_work_buf, multibyte;
+code_conversion_save (int with_work_buf, int multibyte)
{
Lisp_Object workbuf = Qnil;
}
int
-decode_coding_gap (coding, chars, bytes)
- struct coding_system *coding;
- EMACS_INT chars, bytes;
+decode_coding_gap (struct coding_system *coding,
+ EMACS_INT chars, EMACS_INT bytes)
{
- int count = specpdl_ptr - specpdl;
+ int count = SPECPDL_INDEX ();
Lisp_Object attrs;
code_conversion_save (0, 0);
}
int
-encode_coding_gap (coding, chars, bytes)
- struct coding_system *coding;
- EMACS_INT chars, bytes;
+encode_coding_gap (struct coding_system *coding,
+ EMACS_INT chars, EMACS_INT bytes)
{
- int count = specpdl_ptr - specpdl;
+ int count = SPECPDL_INDEX ();
code_conversion_save (0, 0);
*/
void
-decode_coding_object (coding, src_object, from, from_byte, to, to_byte,
- dst_object)
- struct coding_system *coding;
- Lisp_Object src_object;
- EMACS_INT from, from_byte, to, to_byte;
- Lisp_Object dst_object;
+decode_coding_object (struct coding_system *coding,
+ Lisp_Object src_object,
+ EMACS_INT from, EMACS_INT from_byte,
+ EMACS_INT to, EMACS_INT to_byte,
+ Lisp_Object dst_object)
{
- int count = specpdl_ptr - specpdl;
+ int count = SPECPDL_INDEX ();
unsigned char *destination;
EMACS_INT dst_bytes;
EMACS_INT chars = to - from;
}
if (BEGV < GPT && GPT < BEGV + coding->produced_char)
move_gap_both (BEGV, BEGV_BYTE);
- bcopy (BEGV_ADDR, destination, coding->produced);
+ memcpy (destination, BEGV_ADDR, coding->produced);
coding->destination = destination;
}
}
void
-encode_coding_object (coding, src_object, from, from_byte, to, to_byte,
- dst_object)
- struct coding_system *coding;
- Lisp_Object src_object;
- EMACS_INT from, from_byte, to, to_byte;
- Lisp_Object dst_object;
+encode_coding_object (struct coding_system *coding,
+ Lisp_Object src_object,
+ EMACS_INT from, EMACS_INT from_byte,
+ EMACS_INT to, EMACS_INT to_byte,
+ Lisp_Object dst_object)
{
- int count = specpdl_ptr - specpdl;
+ int count = SPECPDL_INDEX ();
EMACS_INT chars = to - from;
EMACS_INT bytes = to_byte - from_byte;
Lisp_Object attrs;
Lisp_Object
-preferred_coding_system ()
+preferred_coding_system (void)
{
int id = coding_categories[coding_priorities[0]].id;
doc: /* Return t if OBJECT is nil or a coding-system.
See the documentation of `define-coding-system' for information
about coding-system objects. */)
- (object)
- Lisp_Object object;
+ (Lisp_Object object)
{
if (NILP (object)
|| CODING_SYSTEM_ID (object) >= 0)
DEFUN ("read-non-nil-coding-system", Fread_non_nil_coding_system,
Sread_non_nil_coding_system, 1, 1, 0,
doc: /* Read a coding system from the minibuffer, prompting with string PROMPT. */)
- (prompt)
- Lisp_Object prompt;
+ (Lisp_Object prompt)
{
Lisp_Object val;
do
If the user enters null input, return second argument DEFAULT-CODING-SYSTEM.
Ignores case when completing coding systems (all Emacs coding systems
are lower-case). */)
- (prompt, default_coding_system)
- Lisp_Object prompt, default_coding_system;
+ (Lisp_Object prompt, Lisp_Object default_coding_system)
{
Lisp_Object val;
int count = SPECPDL_INDEX ();
If valid, return CODING-SYSTEM, else signal a `coding-system-error' error.
It is valid if it is nil or a symbol defined as a coding system by the
function `define-coding-system'. */)
- (coding_system)
- Lisp_Object coding_system;
+ (Lisp_Object coding_system)
{
Lisp_Object define_form;
\f
/* Detect how the bytes at SRC of length SRC_BYTES are encoded. If
HIGHEST is nonzero, return the coding system of the highest
- priority among the detected coding systems. Otherwize return a
+ priority among the detected coding systems. Otherwise return a
list of detected coding systems sorted by their priorities. If
MULTIBYTEP is nonzero, it is assumed that the bytes are in correct
multibyte form but contains only ASCII and eight-bit chars.
detect only text-format. */
Lisp_Object
-detect_coding_system (src, src_chars, src_bytes, highest, multibytep,
- coding_system)
- const unsigned char *src;
- EMACS_INT src_chars, src_bytes;
- int highest;
- int multibytep;
- Lisp_Object coding_system;
+detect_coding_system (const unsigned char *src,
+ EMACS_INT src_chars, EMACS_INT src_bytes,
+ int highest, int multibytep,
+ Lisp_Object coding_system)
{
const unsigned char *src_end = src + src_bytes;
Lisp_Object attrs, eol_type;
If optional argument HIGHEST is non-nil, return the coding system of
highest priority. */)
- (start, end, highest)
- Lisp_Object start, end, highest;
+ (Lisp_Object start, Lisp_Object end, Lisp_Object highest)
{
int from, to;
int from_byte, to_byte;
If optional argument HIGHEST is non-nil, return the coding system of
highest priority. */)
- (string, highest)
- Lisp_Object string, highest;
+ (Lisp_Object string, Lisp_Object highest)
{
CHECK_STRING (string);
static INLINE int
-char_encodable_p (c, attrs)
- int c;
- Lisp_Object attrs;
+char_encodable_p (int c, Lisp_Object attrs)
{
Lisp_Object tail;
struct charset *charset;
Ffind_coding_systems_region_internal,
Sfind_coding_systems_region_internal, 2, 3, 0,
doc: /* Internal use only. */)
- (start, end, exclude)
- Lisp_Object start, end, exclude;
+ (Lisp_Object start, Lisp_Object end, Lisp_Object exclude)
{
Lisp_Object coding_attrs_list, safe_codings;
EMACS_INT start_byte, end_byte;
If optional 5th argument STRING is non-nil, it is a string to search
for un-encodable characters. In that case, START and END are indexes
to the string. */)
- (start, end, coding_system, count, string)
- Lisp_Object start, end, coding_system, count, string;
+ (Lisp_Object start, Lisp_Object end, Lisp_Object coding_system, Lisp_Object count, Lisp_Object string)
{
int n;
struct coding_system coding;
If the current buffer (or START if it is a string) is unibyte, the value
is nil. */)
- (start, end, coding_system_list)
- Lisp_Object start, end, coding_system_list;
+ (Lisp_Object start, Lisp_Object end, Lisp_Object coding_system_list)
{
Lisp_Object list;
EMACS_INT start_byte, end_byte;
Lisp_Object
-code_convert_region (start, end, coding_system, dst_object, encodep, norecord)
- Lisp_Object start, end, coding_system, dst_object;
- int encodep, norecord;
+code_convert_region (Lisp_Object start, Lisp_Object end,
+ Lisp_Object coding_system, Lisp_Object dst_object,
+ int encodep, int norecord)
{
struct coding_system coding;
EMACS_INT from, from_byte, to, to_byte;
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.) */)
- (start, end, coding_system, destination)
- Lisp_Object start, end, coding_system, destination;
+ (Lisp_Object start, Lisp_Object end, Lisp_Object coding_system, Lisp_Object destination)
{
return code_convert_region (start, end, coding_system, destination, 0, 0);
}
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.) */)
- (start, end, coding_system, destination)
- Lisp_Object start, end, coding_system, destination;
+ (Lisp_Object start, Lisp_Object end, Lisp_Object coding_system, Lisp_Object destination)
{
return code_convert_region (start, end, coding_system, destination, 1, 0);
}
Lisp_Object
-code_convert_string (string, coding_system, dst_object,
- encodep, nocopy, norecord)
- Lisp_Object string, coding_system, dst_object;
- int encodep, nocopy, norecord;
+code_convert_string (Lisp_Object string, Lisp_Object coding_system,
+ Lisp_Object dst_object, int encodep, int nocopy, int norecord)
{
struct coding_system coding;
EMACS_INT chars, bytes;
ENCODE_FILE, thus we ignore character composition. */
Lisp_Object
-code_convert_string_norecord (string, coding_system, encodep)
- Lisp_Object string, coding_system;
- int encodep;
+code_convert_string_norecord (Lisp_Object string, Lisp_Object coding_system,
+ int encodep)
{
return code_convert_string (string, coding_system, Qt, encodep, 0, 1);
}
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, buffer)
- Lisp_Object string, coding_system, nocopy, buffer;
+ (Lisp_Object string, Lisp_Object coding_system, Lisp_Object nocopy, Lisp_Object buffer)
{
return code_convert_string (string, coding_system, buffer,
0, ! NILP (nocopy), 0);
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, buffer)
- Lisp_Object string, coding_system, nocopy, buffer;
+ (Lisp_Object string, Lisp_Object coding_system, Lisp_Object nocopy, Lisp_Object buffer)
{
return code_convert_string (string, coding_system, buffer,
1, ! NILP (nocopy), 1);
DEFUN ("decode-sjis-char", Fdecode_sjis_char, Sdecode_sjis_char, 1, 1, 0,
doc: /* Decode a Japanese character which has CODE in shift_jis encoding.
Return the corresponding character. */)
- (code)
- Lisp_Object code;
+ (Lisp_Object code)
{
Lisp_Object spec, attrs, val;
struct charset *charset_roman, *charset_kanji, *charset_kana, *charset;
DEFUN ("encode-sjis-char", Fencode_sjis_char, Sencode_sjis_char, 1, 1, 0,
doc: /* Encode a Japanese character CH to shift_jis encoding.
Return the corresponding code in SJIS. */)
- (ch)
- Lisp_Object ch;
+ (Lisp_Object ch)
{
Lisp_Object spec, attrs, charset_list;
int c;
DEFUN ("decode-big5-char", Fdecode_big5_char, Sdecode_big5_char, 1, 1, 0,
doc: /* Decode a Big5 character which has CODE in BIG5 coding system.
Return the corresponding character. */)
- (code)
- Lisp_Object code;
+ (Lisp_Object code)
{
Lisp_Object spec, attrs, val;
struct charset *charset_roman, *charset_big5, *charset;
DEFUN ("encode-big5-char", Fencode_big5_char, Sencode_big5_char, 1, 1, 0,
doc: /* Encode the Big5 character CH to BIG5 coding system.
Return the corresponding character code in Big5. */)
- (ch)
- Lisp_Object ch;
+ (Lisp_Object ch)
{
Lisp_Object spec, attrs, charset_list;
struct charset *charset;
DEFUN ("set-terminal-coding-system-internal", Fset_terminal_coding_system_internal,
Sset_terminal_coding_system_internal, 1, 2, 0,
doc: /* Internal use only. */)
- (coding_system, terminal)
- Lisp_Object coding_system;
- Lisp_Object terminal;
+ (Lisp_Object coding_system, Lisp_Object terminal)
{
- struct coding_system *terminal_coding = TERMINAL_TERMINAL_CODING (get_terminal (terminal, 1));
+ struct terminal *term = get_terminal (terminal, 1);
+ struct coding_system *terminal_coding = TERMINAL_TERMINAL_CODING (term);
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->mode |= CODING_MODE_SAFE_ENCODING;
- /* Characer composition should be disabled. */
+ /* Character composition should be disabled. */
terminal_coding->common_flags &= ~CODING_ANNOTATE_COMPOSITION_MASK;
terminal_coding->src_multibyte = 1;
terminal_coding->dst_multibyte = 0;
+ if (terminal_coding->common_flags & CODING_REQUIRE_ENCODING_MASK)
+ term->charset_list = coding_charset_list (terminal_coding);
+ else
+ term->charset_list = Fcons (Qascii, Qnil);
return Qnil;
}
Fset_safe_terminal_coding_system_internal,
Sset_safe_terminal_coding_system_internal, 1, 1, 0,
doc: /* Internal use only. */)
- (coding_system)
- Lisp_Object coding_system;
+ (Lisp_Object coding_system)
{
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.common_flags &= ~CODING_ANNOTATE_COMPOSITION_MASK;
safe_terminal_coding.src_multibyte = 1;
safe_terminal_coding.dst_multibyte = 0;
doc: /* Return coding system specified for terminal output on the given terminal.
TERMINAL may be a terminal object, a frame, or nil for the selected
frame's terminal device. */)
- (terminal)
- Lisp_Object terminal;
+ (Lisp_Object terminal)
{
struct coding_system *terminal_coding
= TERMINAL_TERMINAL_CODING (get_terminal (terminal, 1));
DEFUN ("set-keyboard-coding-system-internal", Fset_keyboard_coding_system_internal,
Sset_keyboard_coding_system_internal, 1, 2, 0,
doc: /* Internal use only. */)
- (coding_system, terminal)
- Lisp_Object coding_system;
- Lisp_Object terminal;
+ (Lisp_Object coding_system, Lisp_Object terminal)
{
struct terminal *t = get_terminal (terminal, 1);
CHECK_SYMBOL (coding_system);
else
Fcheck_coding_system (coding_system);
setup_coding_system (coding_system, TERMINAL_KEYBOARD_CODING (t));
- /* Characer composition should be disabled. */
+ /* Character composition should be disabled. */
TERMINAL_KEYBOARD_CODING (t)->common_flags
&= ~CODING_ANNOTATE_COMPOSITION_MASK;
return Qnil;
DEFUN ("keyboard-coding-system",
Fkeyboard_coding_system, Skeyboard_coding_system, 0, 1, 0,
doc: /* Return coding system specified for decoding keyboard input. */)
- (terminal)
- Lisp_Object terminal;
+ (Lisp_Object terminal)
{
return CODING_ID_NAME (TERMINAL_KEYBOARD_CODING
(get_terminal (terminal, 1))->id);
contents of BUFFER instead of reading the file.
usage: (find-operation-coding-system OPERATION ARGUMENTS...) */)
- (nargs, args)
- int nargs;
- Lisp_Object *args;
+ (int nargs, Lisp_Object *args)
{
Lisp_Object operation, target_idx, target, val;
register Lisp_Object chain;
all but the first one are ignored.
usage: (set-coding-system-priority &rest coding-systems) */)
- (nargs, args)
- int nargs;
- Lisp_Object *args;
+ (int nargs, Lisp_Object *args)
{
int i, j;
int changed[coding_category_max];
enum coding_category priorities[coding_category_max];
- bzero (changed, sizeof changed);
+ memset (changed, 0, sizeof changed);
for (i = j = 0; i < nargs; i++)
{
priorities[i] = coding_priorities[j];
}
- bcopy (priorities, coding_priorities, sizeof priorities);
+ memcpy (coding_priorities, priorities, sizeof priorities);
/* Update `coding-category-list'. */
Vcoding_category_list = Qnil;
assigned to each coding category (see `coding-category-list').
HIGHESTP non-nil means just return the highest priority one. */)
- (highestp)
- Lisp_Object highestp;
+ (Lisp_Object highestp)
{
int i;
Lisp_Object val;
static const char *const suffixes[] = { "-unix", "-dos", "-mac" };
static Lisp_Object
-make_subsidiaries (base)
- Lisp_Object base;
+make_subsidiaries (Lisp_Object base)
{
Lisp_Object subsidiaries;
int base_name_len = SBYTES (SYMBOL_NAME (base));
char *buf = (char *) alloca (base_name_len + 6);
int i;
- bcopy (SDATA (SYMBOL_NAME (base)), buf, base_name_len);
+ memcpy (buf, SDATA (SYMBOL_NAME (base)), base_name_len);
subsidiaries = Fmake_vector (make_number (3), Qnil);
for (i = 0; i < 3; i++)
{
- bcopy (suffixes[i], buf + base_name_len, strlen (suffixes[i]) + 1);
+ memcpy (buf + base_name_len, suffixes[i], strlen (suffixes[i]) + 1);
ASET (subsidiaries, i, intern (buf));
}
return subsidiaries;
Sdefine_coding_system_internal, coding_arg_max, MANY, 0,
doc: /* For internal use only.
usage: (define-coding-system-internal ...) */)
- (nargs, args)
- int nargs;
- Lisp_Object *args;
+ (int nargs, Lisp_Object *args)
{
Lisp_Object name;
Lisp_Object spec_vec; /* [ ATTRS ALIASE EOL_TYPE ] */
If Nth element is a list of charset IDs, N is the first byte
of one of them. The list is sorted by dimensions of the
- charsets. A charset of smaller dimension comes firtst. */
+ charsets. A charset of smaller dimension comes first. */
val = Fmake_vector (make_number (256), Qnil);
for (tail = charset_list; CONSP (tail); tail = XCDR (tail))
DEFUN ("coding-system-put", Fcoding_system_put, Scoding_system_put,
3, 3, 0,
doc: /* Change value in CODING-SYSTEM's property list PROP to VAL. */)
- (coding_system, prop, val)
- Lisp_Object coding_system, prop, val;
+ (Lisp_Object coding_system, Lisp_Object prop, Lisp_Object val)
{
Lisp_Object spec, attrs;
DEFUN ("define-coding-system-alias", Fdefine_coding_system_alias,
Sdefine_coding_system_alias, 2, 2, 0,
doc: /* Define ALIAS as an alias for CODING-SYSTEM. */)
- (alias, coding_system)
- Lisp_Object alias, coding_system;
+ (Lisp_Object alias, Lisp_Object coding_system)
{
Lisp_Object spec, aliases, eol_type, val;
1, 1, 0,
doc: /* Return the base of CODING-SYSTEM.
Any alias or subsidiary coding system is not a base coding system. */)
- (coding_system)
- Lisp_Object coding_system;
+ (Lisp_Object coding_system)
{
Lisp_Object spec, attrs;
DEFUN ("coding-system-plist", Fcoding_system_plist, Scoding_system_plist,
1, 1, 0,
doc: "Return the property list of CODING-SYSTEM.")
- (coding_system)
- Lisp_Object coding_system;
+ (Lisp_Object coding_system)
{
Lisp_Object spec, attrs;
DEFUN ("coding-system-aliases", Fcoding_system_aliases, Scoding_system_aliases,
1, 1, 0,
doc: /* Return the list of aliases of CODING-SYSTEM. */)
- (coding_system)
- Lisp_Object coding_system;
+ (Lisp_Object coding_system)
{
Lisp_Object spec;
A vector value indicates that a format of end-of-line should be
detected automatically. Nth element of the vector is the subsidiary
coding system whose eol-type is N. */)
- (coding_system)
- Lisp_Object coding_system;
+ (Lisp_Object coding_system)
{
Lisp_Object spec, eol_type;
int n;
/*** 9. Post-amble ***/
void
-init_coding_once ()
+init_coding_once (void)
{
int i;
#ifdef emacs
void
-syms_of_coding ()
+syms_of_coding (void)
{
staticpro (&Vcoding_system_hash_table);
{
one algorithm agrees with a byte sequence of source text, the coding
system bound to the corresponding coding-category is selected.
-Don't modify this variable directly, but use `set-coding-priority'. */);
+Don't modify this variable directly, but use `set-coding-system-priority'. */);
{
int i;
for (i = 0; i < coding_category_max; i++)
Fset (AREF (Vcoding_category_table, i), Qno_conversion);
}
-#if defined (MSDOS) || defined (WINDOWSNT)
+#if defined (DOS_NT)
system_eol_type = Qdos;
#else
system_eol_type = Qunix;
}
char *
-emacs_strerror (error_number)
- int error_number;
+emacs_strerror (int error_number)
{
char *str;
HCoop / bpt / emacs.git / blobdiff