Lisp_Object Vfile_name_coding_system;
/* Table of symbols identifying each coding category. */
-Lisp_Object coding_category_symbol[CODING_CATEGORY_LAST + 1];
+Lisp_Object coding_category_symbol[CODING_CATEGORY_LAST];
struct file_coding_dump {
/* Coding system currently associated with each coding category. */
- Lisp_Object coding_category_system[CODING_CATEGORY_LAST + 1];
+ Lisp_Object coding_category_system[CODING_CATEGORY_LAST];
/* Table of all coding categories in decreasing order of priority.
This describes a permutation of the possible coding categories. */
- int coding_category_by_priority[CODING_CATEGORY_LAST + 1];
+ int coding_category_by_priority[CODING_CATEGORY_LAST];
#ifdef MULE
Lisp_Object ucs_to_mule_table[65536];
} *fcd;
static const struct lrecord_description fcd_description_1[] = {
- { XD_LISP_OBJECT_ARRAY, offsetof (struct file_coding_dump, coding_category_system), CODING_CATEGORY_LAST + 1 },
+ { XD_LISP_OBJECT_ARRAY, offsetof (struct file_coding_dump, coding_category_system), CODING_CATEGORY_LAST },
#ifdef MULE
- { XD_LISP_OBJECT_ARRAY, offsetof (struct file_coding_dump, ucs_to_mule_table), 65536 },
+ { XD_LISP_OBJECT_ARRAY, offsetof (struct file_coding_dump, ucs_to_mule_table), countof (fcd->ucs_to_mule_table) },
#endif
{ XD_END }
};
#ifdef MULE
struct detection_state;
static int detect_coding_sjis (struct detection_state *st,
- const unsigned char *src,
- unsigned int n);
-static void decode_coding_sjis (Lstream *decoding,
- const unsigned char *src,
- unsigned_char_dynarr *dst,
- unsigned int n);
-static void encode_coding_sjis (Lstream *encoding,
- const unsigned char *src,
- unsigned_char_dynarr *dst,
- unsigned int n);
+ const Extbyte *src, Lstream_data_count n);
+static void decode_coding_sjis (Lstream *decoding, const Extbyte *src,
+ unsigned_char_dynarr *dst, Lstream_data_count n);
+static void encode_coding_sjis (Lstream *encoding, const Bufbyte *src,
+ unsigned_char_dynarr *dst, Lstream_data_count n);
static int detect_coding_big5 (struct detection_state *st,
- const unsigned char *src,
- unsigned int n);
-static void decode_coding_big5 (Lstream *decoding,
- const unsigned char *src,
- unsigned_char_dynarr *dst, unsigned int n);
-static void encode_coding_big5 (Lstream *encoding,
- const unsigned char *src,
- unsigned_char_dynarr *dst, unsigned int n);
+ const Extbyte *src, Lstream_data_count n);
+static void decode_coding_big5 (Lstream *decoding, const Extbyte *src,
+ unsigned_char_dynarr *dst, Lstream_data_count n);
+static void encode_coding_big5 (Lstream *encoding, const Bufbyte *src,
+ unsigned_char_dynarr *dst, Lstream_data_count n);
static int detect_coding_ucs4 (struct detection_state *st,
- const unsigned char *src,
- unsigned int n);
-static void decode_coding_ucs4 (Lstream *decoding,
- const unsigned char *src,
- unsigned_char_dynarr *dst, unsigned int n);
-static void encode_coding_ucs4 (Lstream *encoding,
- const unsigned char *src,
- unsigned_char_dynarr *dst, unsigned int n);
+ const Extbyte *src, Lstream_data_count n);
+static void decode_coding_ucs4 (Lstream *decoding, const Extbyte *src,
+ unsigned_char_dynarr *dst, Lstream_data_count n);
+static void encode_coding_ucs4 (Lstream *encoding, const Bufbyte *src,
+ unsigned_char_dynarr *dst, Lstream_data_count n);
static int detect_coding_utf8 (struct detection_state *st,
- const unsigned char *src,
- unsigned int n);
-static void decode_coding_utf8 (Lstream *decoding,
- const unsigned char *src,
- unsigned_char_dynarr *dst, unsigned int n);
-static void encode_coding_utf8 (Lstream *encoding,
- const unsigned char *src,
- unsigned_char_dynarr *dst, unsigned int n);
+ const Extbyte *src, Lstream_data_count n);
+static void decode_coding_utf8 (Lstream *decoding, const Extbyte *src,
+ unsigned_char_dynarr *dst, Lstream_data_count n);
+static void encode_coding_utf8 (Lstream *encoding, const Bufbyte *src,
+ unsigned_char_dynarr *dst, Lstream_data_count n);
static int postprocess_iso2022_mask (int mask);
static void reset_iso2022 (Lisp_Object coding_system,
struct iso2022_decoder *iso);
static int detect_coding_iso2022 (struct detection_state *st,
- const unsigned char *src,
- unsigned int n);
-static void decode_coding_iso2022 (Lstream *decoding,
- const unsigned char *src,
- unsigned_char_dynarr *dst, unsigned int n);
-static void encode_coding_iso2022 (Lstream *encoding,
- const unsigned char *src,
- unsigned_char_dynarr *dst, unsigned int n);
+ const Extbyte *src, Lstream_data_count n);
+static void decode_coding_iso2022 (Lstream *decoding, const Extbyte *src,
+ unsigned_char_dynarr *dst, Lstream_data_count n);
+static void encode_coding_iso2022 (Lstream *encoding, const Bufbyte *src,
+ unsigned_char_dynarr *dst, Lstream_data_count n);
#endif /* MULE */
-static void decode_coding_no_conversion (Lstream *decoding,
- const unsigned char *src,
- unsigned_char_dynarr *dst,
- unsigned int n);
-static void encode_coding_no_conversion (Lstream *encoding,
- const unsigned char *src,
- unsigned_char_dynarr *dst,
- unsigned int n);
-static void mule_decode (Lstream *decoding, const unsigned char *src,
- unsigned_char_dynarr *dst, unsigned int n);
-static void mule_encode (Lstream *encoding, const unsigned char *src,
- unsigned_char_dynarr *dst, unsigned int n);
+static void decode_coding_no_conversion (Lstream *decoding, const Extbyte *src,
+ unsigned_char_dynarr *dst, Lstream_data_count n);
+static void encode_coding_no_conversion (Lstream *encoding, const Bufbyte *src,
+ unsigned_char_dynarr *dst, Lstream_data_count n);
+static void mule_decode (Lstream *decoding, const Extbyte *src,
+ unsigned_char_dynarr *dst, Lstream_data_count n);
+static void mule_encode (Lstream *encoding, const Bufbyte *src,
+ unsigned_char_dynarr *dst, Lstream_data_count n);
typedef struct codesys_prop codesys_prop;
struct codesys_prop
{
switch (type)
{
- default: abort ();
+ default: ABORT ();
case EOL_LF: return Qlf;
case EOL_CRLF: return Qcrlf;
case EOL_CR: return Qcr;
JIS (the Japanese encoding commonly used for e-mail), EUC (the
standard Unix encoding for Japanese and other languages), and
Compound Text (the encoding used in X11). You can specify more
- specific information about the conversion with the FLAGS argument.
+ specific information about the conversion with the PROPS argument.
'big5
Big5 (the encoding commonly used for Taiwanese).
'ccl
'post-read-conversion
Function called after a file has been read in, to perform the
- decoding. Called with two arguments, BEG and END, denoting
+ decoding. Called with two arguments, START and END, denoting
a region of the current buffer to be decoded.
'pre-write-conversion
Function called before a file is written out, to perform the
- encoding. Called with two arguments, BEG and END, denoting
+ encoding. Called with two arguments, START and END, denoting
a region of the current buffer to be encoded.
(name, type, doc_string, props))
{
Lisp_Coding_System *codesys;
- Lisp_Object rest, key, value;
enum coding_system_type ty;
int need_to_setup_eol_systems = 1;
CHECK_STRING (doc_string);
CODING_SYSTEM_DOC_STRING (codesys) = doc_string;
- EXTERNAL_PROPERTY_LIST_LOOP (rest, key, value, props)
- {
- if (EQ (key, Qmnemonic))
- {
- if (!NILP (value))
- CHECK_STRING (value);
- CODING_SYSTEM_MNEMONIC (codesys) = value;
- }
+ {
+ EXTERNAL_PROPERTY_LIST_LOOP_3 (key, value, props)
+ {
+ if (EQ (key, Qmnemonic))
+ {
+ if (!NILP (value))
+ CHECK_STRING (value);
+ CODING_SYSTEM_MNEMONIC (codesys) = value;
+ }
- else if (EQ (key, Qeol_type))
- {
- need_to_setup_eol_systems = NILP (value);
- if (EQ (value, Qt))
- value = Qnil;
- CODING_SYSTEM_EOL_TYPE (codesys) = symbol_to_eol_type (value);
- }
+ else if (EQ (key, Qeol_type))
+ {
+ need_to_setup_eol_systems = NILP (value);
+ if (EQ (value, Qt))
+ value = Qnil;
+ CODING_SYSTEM_EOL_TYPE (codesys) = symbol_to_eol_type (value);
+ }
- else if (EQ (key, Qpost_read_conversion)) CODING_SYSTEM_POST_READ_CONVERSION (codesys) = value;
- else if (EQ (key, Qpre_write_conversion)) CODING_SYSTEM_PRE_WRITE_CONVERSION (codesys) = value;
+ else if (EQ (key, Qpost_read_conversion)) CODING_SYSTEM_POST_READ_CONVERSION (codesys) = value;
+ else if (EQ (key, Qpre_write_conversion)) CODING_SYSTEM_PRE_WRITE_CONVERSION (codesys) = value;
#ifdef MULE
- else if (ty == CODESYS_ISO2022)
- {
+ else if (ty == CODESYS_ISO2022)
+ {
#define FROB_INITIAL_CHARSET(charset_num) \
CODING_SYSTEM_ISO2022_INITIAL_CHARSET (codesys, charset_num) = \
((EQ (value, Qt) || EQ (value, Qnil)) ? value : Fget_charset (value))
- if (EQ (key, Qcharset_g0)) FROB_INITIAL_CHARSET (0);
- else if (EQ (key, Qcharset_g1)) FROB_INITIAL_CHARSET (1);
- else if (EQ (key, Qcharset_g2)) FROB_INITIAL_CHARSET (2);
- else if (EQ (key, Qcharset_g3)) FROB_INITIAL_CHARSET (3);
+ if (EQ (key, Qcharset_g0)) FROB_INITIAL_CHARSET (0);
+ else if (EQ (key, Qcharset_g1)) FROB_INITIAL_CHARSET (1);
+ else if (EQ (key, Qcharset_g2)) FROB_INITIAL_CHARSET (2);
+ else if (EQ (key, Qcharset_g3)) FROB_INITIAL_CHARSET (3);
#define FROB_FORCE_CHARSET(charset_num) \
CODING_SYSTEM_ISO2022_FORCE_CHARSET_ON_OUTPUT (codesys, charset_num) = !NILP (value)
- else if (EQ (key, Qforce_g0_on_output)) FROB_FORCE_CHARSET (0);
- else if (EQ (key, Qforce_g1_on_output)) FROB_FORCE_CHARSET (1);
- else if (EQ (key, Qforce_g2_on_output)) FROB_FORCE_CHARSET (2);
- else if (EQ (key, Qforce_g3_on_output)) FROB_FORCE_CHARSET (3);
+ else if (EQ (key, Qforce_g0_on_output)) FROB_FORCE_CHARSET (0);
+ else if (EQ (key, Qforce_g1_on_output)) FROB_FORCE_CHARSET (1);
+ else if (EQ (key, Qforce_g2_on_output)) FROB_FORCE_CHARSET (2);
+ else if (EQ (key, Qforce_g3_on_output)) FROB_FORCE_CHARSET (3);
#define FROB_BOOLEAN_PROPERTY(prop) \
CODING_SYSTEM_ISO2022_##prop (codesys) = !NILP (value)
- else if (EQ (key, Qshort)) FROB_BOOLEAN_PROPERTY (SHORT);
- else if (EQ (key, Qno_ascii_eol)) FROB_BOOLEAN_PROPERTY (NO_ASCII_EOL);
- else if (EQ (key, Qno_ascii_cntl)) FROB_BOOLEAN_PROPERTY (NO_ASCII_CNTL);
- else if (EQ (key, Qseven)) FROB_BOOLEAN_PROPERTY (SEVEN);
- else if (EQ (key, Qlock_shift)) FROB_BOOLEAN_PROPERTY (LOCK_SHIFT);
- else if (EQ (key, Qno_iso6429)) FROB_BOOLEAN_PROPERTY (NO_ISO6429);
- else if (EQ (key, Qescape_quoted)) FROB_BOOLEAN_PROPERTY (ESCAPE_QUOTED);
+ else if (EQ (key, Qshort)) FROB_BOOLEAN_PROPERTY (SHORT);
+ else if (EQ (key, Qno_ascii_eol)) FROB_BOOLEAN_PROPERTY (NO_ASCII_EOL);
+ else if (EQ (key, Qno_ascii_cntl)) FROB_BOOLEAN_PROPERTY (NO_ASCII_CNTL);
+ else if (EQ (key, Qseven)) FROB_BOOLEAN_PROPERTY (SEVEN);
+ else if (EQ (key, Qlock_shift)) FROB_BOOLEAN_PROPERTY (LOCK_SHIFT);
+ else if (EQ (key, Qno_iso6429)) FROB_BOOLEAN_PROPERTY (NO_ISO6429);
+ else if (EQ (key, Qescape_quoted)) FROB_BOOLEAN_PROPERTY (ESCAPE_QUOTED);
+
+ else if (EQ (key, Qinput_charset_conversion))
+ {
+ codesys->iso2022.input_conv =
+ Dynarr_new (charset_conversion_spec);
+ parse_charset_conversion_specs (codesys->iso2022.input_conv,
+ value);
+ }
+ else if (EQ (key, Qoutput_charset_conversion))
+ {
+ codesys->iso2022.output_conv =
+ Dynarr_new (charset_conversion_spec);
+ parse_charset_conversion_specs (codesys->iso2022.output_conv,
+ value);
+ }
+ else
+ signal_simple_error ("Unrecognized property", key);
+ }
+ else if (EQ (type, Qccl))
+ {
+ Lisp_Object sym;
+ struct ccl_program test_ccl;
+ Extbyte *suffix;
+
+ /* Check key first. */
+ if (EQ (key, Qdecode))
+ suffix = "-ccl-decode";
+ else if (EQ (key, Qencode))
+ suffix = "-ccl-encode";
+ else
+ signal_simple_error ("Unrecognized property", key);
+
+ /* If value is vector, register it as a ccl program
+ associated with an newly created symbol for
+ backward compatibility. */
+ if (VECTORP (value))
+ {
+ sym = Fintern (concat2 (Fsymbol_name (name),
+ build_string (suffix)),
+ Qnil);
+ Fregister_ccl_program (sym, value);
+ }
+ else
+ {
+ CHECK_SYMBOL (value);
+ sym = value;
+ }
+ /* check if the given ccl programs are valid. */
+ if (setup_ccl_program (&test_ccl, sym) < 0)
+ signal_simple_error ("Invalid CCL program", value);
+
+ if (EQ (key, Qdecode))
+ CODING_SYSTEM_CCL_DECODE (codesys) = sym;
+ else if (EQ (key, Qencode))
+ CODING_SYSTEM_CCL_ENCODE (codesys) = sym;
- else if (EQ (key, Qinput_charset_conversion))
- {
- codesys->iso2022.input_conv =
- Dynarr_new (charset_conversion_spec);
- parse_charset_conversion_specs (codesys->iso2022.input_conv,
- value);
- }
- else if (EQ (key, Qoutput_charset_conversion))
- {
- codesys->iso2022.output_conv =
- Dynarr_new (charset_conversion_spec);
- parse_charset_conversion_specs (codesys->iso2022.output_conv,
- value);
- }
- else
- signal_simple_error ("Unrecognized property", key);
- }
- else if (EQ (type, Qccl))
- {
- if (EQ (key, Qdecode))
- {
- CHECK_VECTOR (value);
- CODING_SYSTEM_CCL_DECODE (codesys) = value;
- }
- else if (EQ (key, Qencode))
- {
- CHECK_VECTOR (value);
- CODING_SYSTEM_CCL_ENCODE (codesys) = value;
- }
- else
- signal_simple_error ("Unrecognized property", key);
- }
+ }
#endif /* MULE */
- else
- signal_simple_error ("Unrecognized property", key);
- }
+ else
+ signal_simple_error ("Unrecognized property", key);
+ }
+ }
if (need_to_setup_eol_systems)
setup_eol_coding_systems (codesys);
return aliasee;
else
signal_simple_error ("Symbol is not a coding system alias", alias);
+ return Qnil; /* To keep the compiler happy */
}
static Lisp_Object
case EOL_LF: new_coding_system = CODING_SYSTEM_EOL_LF (cs); break;
case EOL_CR: new_coding_system = CODING_SYSTEM_EOL_CR (cs); break;
case EOL_CRLF: new_coding_system = CODING_SYSTEM_EOL_CRLF (cs); break;
- default: abort ();
+ default: ABORT (); return Qnil;
}
return NILP (new_coding_system) ? coding_system : new_coding_system;
{
switch (XCODING_SYSTEM_TYPE (Fget_coding_system (coding_system)))
{
- default: abort ();
+ default: ABORT ();
case CODESYS_AUTODETECT: return Qundecided;
#ifdef MULE
case CODESYS_SHIFT_JIS: return Qshift_jis;
break;
#endif /* MULE */
default:
- abort ();
+ ABORT ();
}
}
unparse_charset_conversion_specs
(XCODING_SYSTEM (coding_system)->iso2022.output_conv);
else
- abort ();
+ ABORT ();
}
else if (type == CODESYS_CCL)
{
else if (EQ (prop, Qencode))
return XCODING_SYSTEM_CCL_ENCODE (coding_system);
else
- abort ();
+ ABORT ();
}
#endif /* MULE */
else
- abort ();
+ ABORT ();
return Qnil; /* not reached */
}
int i;
CHECK_SYMBOL (symbol);
- for (i = 0; i <= CODING_CATEGORY_LAST; i++)
+ for (i = 0; i < CODING_CATEGORY_LAST; i++)
if (EQ (coding_category_symbol[i], symbol))
return i;
int i;
Lisp_Object list = Qnil;
- for (i = CODING_CATEGORY_LAST; i >= 0; i--)
+ for (i = CODING_CATEGORY_LAST - 1; i >= 0; i--)
list = Fcons (coding_category_symbol[i], list);
return list;
}
*/
(list))
{
- int category_to_priority[CODING_CATEGORY_LAST + 1];
+ int category_to_priority[CODING_CATEGORY_LAST];
int i, j;
Lisp_Object rest;
/* First generate a list that maps coding categories to priorities. */
- for (i = 0; i <= CODING_CATEGORY_LAST; i++)
+ for (i = 0; i < CODING_CATEGORY_LAST; i++)
category_to_priority[i] = -1;
/* Highest priority comes from the specified list. */
/* Now go through the existing categories by priority to retrieve
the categories not yet specified and preserve their priority
order. */
- for (j = 0; j <= CODING_CATEGORY_LAST; j++)
+ for (j = 0; j < CODING_CATEGORY_LAST; j++)
{
int cat = fcd->coding_category_by_priority[j];
if (category_to_priority[cat] < 0)
/* Now we need to construct the inverse of the mapping we just
constructed. */
- for (i = 0; i <= CODING_CATEGORY_LAST; i++)
+ for (i = 0; i < CODING_CATEGORY_LAST; i++)
fcd->coding_category_by_priority[category_to_priority[i]] = i;
/* Phew! That was confusing. */
int i;
Lisp_Object list = Qnil;
- for (i = CODING_CATEGORY_LAST; i >= 0; i--)
+ for (i = CODING_CATEGORY_LAST - 1; i >= 0; i--)
list = Fcons (coding_category_symbol[fcd->coding_category_by_priority[i]],
list);
return list;
}
static eol_type_t
-detect_eol_type (struct detection_state *st, const unsigned char *src,
- unsigned int n)
+detect_eol_type (struct detection_state *st, const Extbyte *src,
+ Lstream_data_count n)
{
- int c;
-
while (n--)
{
- c = *src++;
+ unsigned char c = *(unsigned char *)src++;
if (c == '\n')
{
if (st->eol.just_saw_cr)
static int
detect_coding_type (struct detection_state *st, const Extbyte *src,
- unsigned int n, int just_do_eol)
+ Lstream_data_count n, int just_do_eol)
{
- int c;
-
if (st->eol_type == EOL_AUTODETECT)
st->eol_type = detect_eol_type (st, src, n);
{
for (; n; n--, src++)
{
- c = *src;
+ unsigned char c = *(unsigned char *) src;
if ((c < 0x20 && !acceptable_control_char_p (c)) || c >= 0x80)
{
st->seen_non_ascii = 1;
#endif
/* Look through the coding categories by priority and find
the first one that is allowed. */
- for (i = 0; i <= CODING_CATEGORY_LAST; i++)
+ for (i = 0; i < CODING_CATEGORY_LAST; i++)
{
cat = fcd->coding_category_by_priority[i];
if ((mask & (1 << cat)) &&
that should be unnecessary with the explicit eol-type argument. */
#define LENGTH(string_constant) (sizeof (string_constant) - 1)
+/* number of leading lines to check for a coding cookie */
+#define LINES_TO_CHECK 2
void
determine_real_coding_system (Lstream *stream, Lisp_Object *codesys_in_out,
Extbyte buf[4096];
Lisp_Object coding_system = Qnil;
Extbyte *p;
- ssize_t nread = Lstream_read (stream, buf, sizeof (buf));
+ Lstream_data_count nread = Lstream_read (stream, buf, sizeof (buf));
Extbyte *scan_end;
+ int lines_checked = 0;
/* Look for initial "-*-"; mode line prefix */
for (p = buf,
scan_end = buf + nread - LENGTH ("-*-coding:?-*-");
p <= scan_end
- && *p != '\n'
- && *p != '\r';
+ && lines_checked < LINES_TO_CHECK;
p++)
if (*p == '-' && *(p+1) == '*' && *(p+2) == '-')
{
for (p = local_vars_beg,
scan_end = buf + nread - LENGTH ("-*-");
p <= scan_end
- && *p != '\n'
- && *p != '\r';
+ && lines_checked < LINES_TO_CHECK;
p++)
if (*p == '-' && *(p+1) == '*' && *(p+2) == '-')
{
}
break;
}
+ /* #### file must use standard EOLs or we miss 2d line */
+ /* #### not to mention this is broken for UTF-16 DOS files */
+ else if (*p == '\n' || *p == '\r')
+ {
+ lines_checked++;
+ /* skip past multibyte (DOS) newline */
+ if (*p == '\r' && *(p+1) == '\n') p++;
+ }
break;
}
+ /* #### file must use standard EOLs or we miss 2d line */
+ /* #### not to mention this is broken for UTF-16 DOS files */
+ else if (*p == '\n' || *p == '\r')
+ {
+ lines_checked++;
+ /* skip past multibyte (DOS) newline */
+ if (*p == '\r' && *(p+1) == '\n') p++;
+ }
if (NILP (coding_system))
do
DEFUN ("detect-coding-region", Fdetect_coding_region, 2, 3, 0, /*
Detect coding system of the text in the region between START and END.
-Returned a list of possible coding systems ordered by priority.
-If only ASCII characters are found, it returns 'undecided or one of
+Return a list of possible coding systems ordered by priority.
+If only ASCII characters are found, return 'undecided or one of
its subsidiary coding systems according to a detected end-of-line
type. Optional arg BUFFER defaults to the current buffer.
*/
decst.mask = ~0;
while (1)
{
- unsigned char random_buffer[4096];
- ssize_t nread = Lstream_read (istr, random_buffer, sizeof (random_buffer));
+ Extbyte random_buffer[4096];
+ Lstream_data_count nread = Lstream_read (istr, random_buffer, sizeof (random_buffer));
if (!nread)
break;
#ifdef MULE
decst.mask = postprocess_iso2022_mask (decst.mask);
#endif
- for (i = CODING_CATEGORY_LAST; i >= 0; i--)
+ for (i = CODING_CATEGORY_LAST - 1; i >= 0; i--)
{
int sys = fcd->coding_category_by_priority[i];
if (decst.mask & (1 << sys))
struct detection_state decst;
};
-static ssize_t decoding_reader (Lstream *stream,
- unsigned char *data, size_t size);
-static ssize_t decoding_writer (Lstream *stream,
- const unsigned char *data, size_t size);
+static Lstream_data_count decoding_reader (Lstream *stream,
+ unsigned char *data, Lstream_data_count size);
+static Lstream_data_count decoding_writer (Lstream *stream,
+ const unsigned char *data, Lstream_data_count size);
static int decoding_rewinder (Lstream *stream);
static int decoding_seekable_p (Lstream *stream);
static int decoding_flusher (Lstream *stream);
/* Read SIZE bytes of data and store it into DATA. We are a decoding stream
so we read data from the other end, decode it, and store it into DATA. */
-static ssize_t
-decoding_reader (Lstream *stream, unsigned char *data, size_t size)
+static Lstream_data_count
+decoding_reader (Lstream *stream, unsigned char *data, Lstream_data_count size)
{
struct decoding_stream *str = DECODING_STREAM_DATA (stream);
unsigned char *orig_data = data;
- ssize_t read_size;
+ Lstream_data_count read_size;
int error_occurred = 0;
/* We need to interface to mule_decode(), which expects to take some
most SIZE bytes, and delete the data from the runoff. */
if (Dynarr_length (str->runoff) > 0)
{
- size_t chunk = min (size, (size_t) Dynarr_length (str->runoff));
+ Lstream_data_count chunk = min (size, (Lstream_data_count) Dynarr_length (str->runoff));
memcpy (data, Dynarr_atp (str->runoff, 0), chunk);
Dynarr_delete_many (str->runoff, 0, chunk);
data += chunk;
/* There might be some more end data produced in the translation.
See the comment above. */
str->flags |= CODING_STATE_END;
- mule_decode (stream, data, str->runoff, read_size);
+ mule_decode (stream, (Extbyte *) data, str->runoff, read_size);
}
if (data - orig_data == 0)
return data - orig_data;
}
-static ssize_t
-decoding_writer (Lstream *stream, const unsigned char *data, size_t size)
+static Lstream_data_count
+decoding_writer (Lstream *stream, const unsigned char *data, Lstream_data_count size)
{
struct decoding_stream *str = DECODING_STREAM_DATA (stream);
- ssize_t retval;
+ Lstream_data_count retval;
/* Decode all our data into the runoff, and then attempt to write
it all out to the other end. Remove whatever chunk we succeeded
in writing. */
- mule_decode (stream, data, str->runoff, size);
+ mule_decode (stream, (Extbyte *) data, str->runoff, size);
retval = Lstream_write (str->other_end, Dynarr_atp (str->runoff, 0),
Dynarr_length (str->runoff));
if (retval > 0)
}
str->counter = 0;
#endif /* MULE */
+ if (CODING_SYSTEM_TYPE (str->codesys) == CODESYS_AUTODETECT
+ || CODING_SYSTEM_EOL_TYPE (str->codesys) == EOL_AUTODETECT)
+ {
+ xzero (str->decst);
+ str->decst.eol_type = EOL_AUTODETECT;
+ str->decst.mask = ~0;
+ }
str->flags = str->ch = 0;
}
be used for both reading and writing. */
static void
-mule_decode (Lstream *decoding, const unsigned char *src,
- unsigned_char_dynarr *dst, unsigned int n)
+mule_decode (Lstream *decoding, const Extbyte *src,
+ unsigned_char_dynarr *dst, Lstream_data_count n)
{
struct decoding_stream *str = DECODING_STREAM_DATA (decoding);
break;
case CODESYS_CCL:
str->ccl.last_block = str->flags & CODING_STATE_END;
- ccl_driver (&str->ccl, src, dst, n, 0, CCL_MODE_DECODING);
+ /* When applying ccl program to stream, MUST NOT set NULL
+ pointer to src. */
+ ccl_driver (&str->ccl, (src ? (unsigned char *)src : (unsigned char*)""),
+ dst, n, 0, CCL_MODE_DECODING);
break;
case CODESYS_ISO2022:
decode_coding_iso2022 (decoding, src, dst, n);
break;
#endif /* MULE */
default:
- abort ();
+ ABORT ();
}
}
char tempbuf[1024]; /* some random amount */
Bufpos newpos, even_newer_pos;
Bufpos oldpos = lisp_buffer_stream_startpos (istr);
- ssize_t size_in_bytes = Lstream_read (istr, tempbuf, sizeof (tempbuf));
+ Lstream_data_count size_in_bytes = Lstream_read (istr, tempbuf, sizeof (tempbuf));
if (!size_in_bytes)
break;
#endif /* MULE */
};
-static ssize_t encoding_reader (Lstream *stream, unsigned char *data, size_t size);
-static ssize_t encoding_writer (Lstream *stream, const unsigned char *data,
- size_t size);
+static Lstream_data_count encoding_reader (Lstream *stream, unsigned char *data, Lstream_data_count size);
+static Lstream_data_count encoding_writer (Lstream *stream, const unsigned char *data,
+ Lstream_data_count size);
static int encoding_rewinder (Lstream *stream);
static int encoding_seekable_p (Lstream *stream);
static int encoding_flusher (Lstream *stream);
/* Read SIZE bytes of data and store it into DATA. We are a encoding stream
so we read data from the other end, encode it, and store it into DATA. */
-static ssize_t
-encoding_reader (Lstream *stream, unsigned char *data, size_t size)
+static Lstream_data_count
+encoding_reader (Lstream *stream, unsigned char *data, Lstream_data_count size)
{
struct encoding_stream *str = ENCODING_STREAM_DATA (stream);
unsigned char *orig_data = data;
- ssize_t read_size;
+ Lstream_data_count read_size;
int error_occurred = 0;
/* We need to interface to mule_encode(), which expects to take some
return data - orig_data;
}
-static ssize_t
-encoding_writer (Lstream *stream, const unsigned char *data, size_t size)
+static Lstream_data_count
+encoding_writer (Lstream *stream, const unsigned char *data, Lstream_data_count size)
{
struct encoding_stream *str = ENCODING_STREAM_DATA (stream);
- ssize_t retval;
+ Lstream_data_count retval;
/* Encode all our data into the runoff, and then attempt to write
it all out to the other end. Remove whatever chunk we succeeded
Store the encoded data into DST. */
static void
-mule_encode (Lstream *encoding, const unsigned char *src,
- unsigned_char_dynarr *dst, unsigned int n)
+mule_encode (Lstream *encoding, const Bufbyte *src,
+ unsigned_char_dynarr *dst, Lstream_data_count n)
{
struct encoding_stream *str = ENCODING_STREAM_DATA (encoding);
break;
case CODESYS_CCL:
str->ccl.last_block = str->flags & CODING_STATE_END;
- ccl_driver (&str->ccl, src, dst, n, 0, CCL_MODE_ENCODING);
+ /* When applying ccl program to stream, MUST NOT set NULL
+ pointer to src. */
+ ccl_driver (&str->ccl, ((src) ? src : (unsigned char*)""),
+ dst, n, 0, CCL_MODE_ENCODING);
break;
case CODESYS_ISO2022:
encode_coding_iso2022 (encoding, src, dst, n);
break;
#endif /* MULE */
default:
- abort ();
+ ABORT ();
}
}
char tempbuf[1024]; /* some random amount */
Bufpos newpos, even_newer_pos;
Bufpos oldpos = lisp_buffer_stream_startpos (istr);
- ssize_t size_in_bytes = Lstream_read (istr, tempbuf, sizeof (tempbuf));
+ Lstream_data_count size_in_bytes = Lstream_read (istr, tempbuf, sizeof (tempbuf));
if (!size_in_bytes)
break;
((c) >= 0xA1 && (c) <= 0xDF)
static int
-detect_coding_sjis (struct detection_state *st, const unsigned char *src,
- unsigned int n)
+detect_coding_sjis (struct detection_state *st, const Extbyte *src, Lstream_data_count n)
{
- int c;
-
while (n--)
{
- c = *src++;
+ unsigned char c = *(unsigned char *)src++;
if (c == ISO_CODE_ESC || c == ISO_CODE_SI || c == ISO_CODE_SO)
return 0;
if (st->shift_jis.in_second_byte)
/* Convert Shift-JIS data to internal format. */
static void
-decode_coding_sjis (Lstream *decoding, const unsigned char *src,
- unsigned_char_dynarr *dst, unsigned int n)
+decode_coding_sjis (Lstream *decoding, const Extbyte *src,
+ unsigned_char_dynarr *dst, Lstream_data_count n)
{
- unsigned char c;
struct decoding_stream *str = DECODING_STREAM_DATA (decoding);
unsigned int flags = str->flags;
unsigned int ch = str->ch;
while (n--)
{
- c = *src++;
+ unsigned char c = *(unsigned char *)src++;
if (ch)
{
/* Convert internally-formatted data to Shift-JIS. */
static void
-encode_coding_sjis (Lstream *encoding, const unsigned char *src,
- unsigned_char_dynarr *dst, unsigned int n)
+encode_coding_sjis (Lstream *encoding, const Bufbyte *src,
+ unsigned_char_dynarr *dst, Lstream_data_count n)
{
- unsigned char c;
struct encoding_stream *str = ENCODING_STREAM_DATA (encoding);
unsigned int flags = str->flags;
unsigned int ch = str->ch;
while (n--)
{
- c = *src++;
+ Bufbyte c = *src++;
if (c == '\n')
{
if (eol_type != EOL_LF && eol_type != EOL_AUTODETECT)
}
DEFUN ("encode-shift-jis-char", Fencode_shift_jis_char, 1, 1, 0, /*
-Encode a JISX0208 character CHAR to SHIFT-JIS coding-system.
+Encode a JISX0208 character CHARACTER to SHIFT-JIS coding-system.
Return the corresponding character code in SHIFT-JIS as a cons of two bytes.
*/
- (ch))
+ (character))
{
Lisp_Object charset;
int c1, c2, s1, s2;
- CHECK_CHAR_COERCE_INT (ch);
- BREAKUP_CHAR (XCHAR (ch), charset, c1, c2);
+ CHECK_CHAR_COERCE_INT (character);
+ BREAKUP_CHAR (XCHAR (character), charset, c1, c2);
if (EQ (charset, Vcharset_japanese_jisx0208))
{
ENCODE_SJIS (c1 | 0x80, c2 | 0x80, s1, s2);
} while (0)
static int
-detect_coding_big5 (struct detection_state *st, const unsigned char *src,
- unsigned int n)
+detect_coding_big5 (struct detection_state *st, const Extbyte *src, Lstream_data_count n)
{
- int c;
-
while (n--)
{
- c = *src++;
+ unsigned char c = *(unsigned char *)src++;
if (c == ISO_CODE_ESC || c == ISO_CODE_SI || c == ISO_CODE_SO ||
(c >= 0x80 && c <= 0xA0))
return 0;
/* Convert Big5 data to internal format. */
static void
-decode_coding_big5 (Lstream *decoding, const unsigned char *src,
- unsigned_char_dynarr *dst, unsigned int n)
+decode_coding_big5 (Lstream *decoding, const Extbyte *src,
+ unsigned_char_dynarr *dst, Lstream_data_count n)
{
- unsigned char c;
struct decoding_stream *str = DECODING_STREAM_DATA (decoding);
unsigned int flags = str->flags;
unsigned int ch = str->ch;
while (n--)
{
- c = *src++;
+ unsigned char c = *(unsigned char *)src++;
if (ch)
{
/* Previous character was first byte of Big5 char. */
/* Convert internally-formatted data to Big5. */
static void
-encode_coding_big5 (Lstream *encoding, const unsigned char *src,
- unsigned_char_dynarr *dst, unsigned int n)
+encode_coding_big5 (Lstream *encoding, const Bufbyte *src,
+ unsigned_char_dynarr *dst, Lstream_data_count n)
{
unsigned char c;
struct encoding_stream *str = ENCODING_STREAM_DATA (encoding);
}
DEFUN ("encode-big5-char", Fencode_big5_char, 1, 1, 0, /*
-Encode the Big5 character CH to BIG5 coding-system.
+Encode the Big5 character CHARACTER in the BIG5 coding-system.
Return the corresponding character code in Big5.
*/
- (ch))
+ (character))
{
Lisp_Object charset;
int c1, c2, b1, b2;
- CHECK_CHAR_COERCE_INT (ch);
- BREAKUP_CHAR (XCHAR (ch), charset, c1, c2);
+ CHECK_CHAR_COERCE_INT (character);
+ BREAKUP_CHAR (XCHAR (character), charset, c1, c2);
if (EQ (charset, Vcharset_chinese_big5_1) ||
EQ (charset, Vcharset_chinese_big5_2))
{
*/
(code, character))
{
- unsigned int c;
+ size_t c;
CHECK_CHAR (character);
- CHECK_INT (code);
+ CHECK_NATNUM (code);
c = XINT (code);
- if (c < sizeof (fcd->ucs_to_mule_table))
+ if (c < countof (fcd->ucs_to_mule_table))
{
fcd->ucs_to_mule_table[c] = character;
return Qt;
static Lisp_Object
ucs_to_char (unsigned long code)
{
- if (code < sizeof (fcd->ucs_to_mule_table))
+ if (code < countof (fcd->ucs_to_mule_table))
{
return fcd->ucs_to_mule_table[code];
}
}
static int
-detect_coding_ucs4 (struct detection_state *st, const unsigned char *src,
- unsigned int n)
+detect_coding_ucs4 (struct detection_state *st, const Extbyte *src, Lstream_data_count n)
{
while (n--)
{
- int c = *src++;
+ unsigned char c = *(unsigned char *)src++;
switch (st->ucs4.in_byte)
{
case 0:
}
static void
-decode_coding_ucs4 (Lstream *decoding, const unsigned char *src,
- unsigned_char_dynarr *dst, unsigned int n)
+decode_coding_ucs4 (Lstream *decoding, const Extbyte *src,
+ unsigned_char_dynarr *dst, Lstream_data_count n)
{
struct decoding_stream *str = DECODING_STREAM_DATA (decoding);
unsigned int flags = str->flags;
while (n--)
{
- unsigned char c = *src++;
+ unsigned char c = *(unsigned char *)src++;
switch (counter)
{
case 0:
}
static void
-encode_coding_ucs4 (Lstream *encoding, const unsigned char *src,
- unsigned_char_dynarr *dst, unsigned int n)
+encode_coding_ucs4 (Lstream *encoding, const Bufbyte *src,
+ unsigned_char_dynarr *dst, Lstream_data_count n)
{
struct encoding_stream *str = ENCODING_STREAM_DATA (encoding);
unsigned int flags = str->flags;
{
/* #### Bother! We don't know how to
handle this yet. */
- Dynarr_add (dst, 0);
- Dynarr_add (dst, 0);
- Dynarr_add (dst, 0);
+ Dynarr_add (dst, '\0');
+ Dynarr_add (dst, '\0');
+ Dynarr_add (dst, '\0');
Dynarr_add (dst, '~');
}
else
}
break;
default:
- abort ();
+ ABORT ();
}
}
}
/************************************************************************/
static int
-detect_coding_utf8 (struct detection_state *st, const unsigned char *src,
- unsigned int n)
+detect_coding_utf8 (struct detection_state *st, const Extbyte *src, Lstream_data_count n)
{
while (n--)
{
- unsigned char c = *src++;
+ unsigned char c = *(unsigned char *)src++;
switch (st->utf8.in_byte)
{
case 0:
}
static void
-decode_coding_utf8 (Lstream *decoding, const unsigned char *src,
- unsigned_char_dynarr *dst, unsigned int n)
+decode_coding_utf8 (Lstream *decoding, const Extbyte *src,
+ unsigned_char_dynarr *dst, Lstream_data_count n)
{
struct decoding_stream *str = DECODING_STREAM_DATA (decoding);
unsigned int flags = str->flags;
while (n--)
{
- unsigned char c = *src++;
+ unsigned char c = *(unsigned char *)src++;
switch (counter)
{
case 0:
}
static void
-encode_coding_utf8 (Lstream *encoding, const unsigned char *src,
- unsigned_char_dynarr *dst, unsigned int n)
+encode_coding_utf8 (Lstream *encoding, const Bufbyte *src,
+ unsigned_char_dynarr *dst, Lstream_data_count n)
{
struct encoding_stream *str = ENCODING_STREAM_DATA (encoding);
unsigned int flags = str->flags;
}
break;
default:
- abort ();
+ ABORT ();
}
}
}
If CHECK_INVALID_CHARSETS is non-zero, check for designation
or invocation of an invalid character set and treat that as
- an unrecognized escape sequence. */
+ an unrecognized escape sequence.
+
+ ********************************************************************
+
+ #### Strategies for error annotation and coding orthogonalization
+
+ We really want to separate out a number of things. Conceptually,
+ there is a nested syntax.
+
+ At the top level is the ISO 2022 extension syntax, including charset
+ designation and invocation, and certain auxiliary controls such as the
+ ISO 6429 direction specification. These are octet-oriented, with the
+ single exception (AFAIK) of the "exit Unicode" sequence which uses the
+ UTF's natural width (1 byte for UTF-7 and UTF-8, 2 bytes for UCS-2 and
+ UTF-16, and 4 bytes for UCS-4 and UTF-32). This will be treated as a
+ (deprecated) special case in Unicode processing.
+
+ The middle layer is ISO 2022 character interpretation. This will depend
+ on the current state of the ISO 2022 registers, and assembles octets
+ into the character's internal representation.
+
+ The lowest level is translating system control conventions. At present
+ this is restricted to newline translation, but one could imagine doing
+ tab conversion or line wrapping here. "Escape from Unicode" processing
+ would be done at this level.
+
+ At each level the parser will verify the syntax. In the case of a
+ syntax error or warning (such as a redundant escape sequence that affects
+ no characters), the parser will take some action, typically inserting the
+ erroneous octets directly into the output and creating an annotation
+ which can be used by higher level I/O to mark the affected region.
+
+ This should make it possible to do something sensible about separating
+ newline convention processing from character construction, and about
+ preventing ISO 2022 escape sequences from being recognized
+ inappropriately.
+
+ The basic strategy will be to have octet classification tables, and
+ switch processing according to the table entry.
+
+ It's possible that, by doing the processing with tables of functions or
+ the like, the parser can be used for both detection and translation. */
static int
parse_iso2022_esc (Lisp_Object codesys, struct iso2022_decoder *iso,
else
{
/* Can this ever be reached? -slb */
- abort();
+ ABORT();
+ return 0;
}
cs = CHARSET_BY_ATTRIBUTES (type, c,
}
static int
-detect_coding_iso2022 (struct detection_state *st, const unsigned char *src,
- unsigned int n)
+detect_coding_iso2022 (struct detection_state *st, const Extbyte *src, Lstream_data_count n)
{
int mask;
while (n--)
{
- int c = *src++;
+ unsigned char c = *(unsigned char *)src++;
if (c >= 0xA0)
{
mask &= ~CODING_CATEGORY_ISO_7_MASK;
/* Convert ISO2022-format data to internal format. */
static void
-decode_coding_iso2022 (Lstream *decoding, const unsigned char *src,
- unsigned_char_dynarr *dst, unsigned int n)
+decode_coding_iso2022 (Lstream *decoding, const Extbyte *src,
+ unsigned_char_dynarr *dst, Lstream_data_count n)
{
struct decoding_stream *str = DECODING_STREAM_DATA (decoding);
unsigned int flags = str->flags;
while (n--)
{
- unsigned char c = *src++;
+ unsigned char c = *(unsigned char *)src++;
if (flags & CODING_STATE_ESCAPE)
{ /* Within ESC sequence */
int retval = parse_iso2022_esc (coding_system, &str->iso2022,
/* Convert internally-formatted data to ISO2022 format. */
static void
-encode_coding_iso2022 (Lstream *encoding, const unsigned char *src,
- unsigned_char_dynarr *dst, unsigned int n)
+encode_coding_iso2022 (Lstream *encoding, const Bufbyte *src,
+ unsigned_char_dynarr *dst, Lstream_data_count n)
{
unsigned char charmask, c;
unsigned char char_boundary;
break;
default:
- abort ();
+ ABORT ();
}
}
char_boundary = 0;
}
break;
default:
- abort ();
+ ABORT ();
}
}
}
contain all 256 possible byte values and that are not to be
interpreted as being in any particular decoding. */
static void
-decode_coding_no_conversion (Lstream *decoding, const unsigned char *src,
- unsigned_char_dynarr *dst, unsigned int n)
+decode_coding_no_conversion (Lstream *decoding, const Extbyte *src,
+ unsigned_char_dynarr *dst, Lstream_data_count n)
{
- unsigned char c;
struct decoding_stream *str = DECODING_STREAM_DATA (decoding);
unsigned int flags = str->flags;
unsigned int ch = str->ch;
while (n--)
{
- c = *src++;
+ unsigned char c = *(unsigned char *)src++;
DECODE_HANDLE_EOL_TYPE (eol_type, c, flags, dst);
DECODE_ADD_BINARY_CHAR (c, dst);
}
static void
-encode_coding_no_conversion (Lstream *encoding, const unsigned char *src,
- unsigned_char_dynarr *dst, unsigned int n)
+encode_coding_no_conversion (Lstream *encoding, const Bufbyte *src,
+ unsigned_char_dynarr *dst, Lstream_data_count n)
{
unsigned char c;
struct encoding_stream *str = ENCODING_STREAM_DATA (encoding);
void
syms_of_file_coding (void)
{
- deferror (&Qcoding_system_error, "coding-system-error",
- "Coding-system error", Qio_error);
+ INIT_LRECORD_IMPLEMENTATION (coding_system);
+
+ DEFERROR_STANDARD (Qcoding_system_error, Qio_error);
DEFSUBR (Fcoding_system_p);
DEFSUBR (Ffind_coding_system);
int i;
fcd = xnew (struct file_coding_dump);
- dumpstruct (&fcd, &fcd_description);
+ dump_add_root_struct_ptr (&fcd, &fcd_description);
/* Initialize to something reasonable ... */
- for (i = 0; i <= CODING_CATEGORY_LAST; i++)
+ for (i = 0; i < CODING_CATEGORY_LAST; i++)
{
fcd->coding_category_system[i] = Qnil;
fcd->coding_category_by_priority[i] = i;
make_lisp_hash_table (50, HASH_TABLE_NON_WEAK, HASH_TABLE_EQ);
the_codesys_prop_dynarr = Dynarr_new (codesys_prop);
- dumpstruct (&the_codesys_prop_dynarr, &codesys_prop_dynarr_description);
+ dump_add_root_struct_ptr (&the_codesys_prop_dynarr, &codesys_prop_dynarr_description);
#define DEFINE_CODESYS_PROP(Prop_Type, Sym) do \
{ \
#ifdef MULE
{
- unsigned int i;
+ size_t i;
- for (i = 0; i < 65536; i++)
+ for (i = 0; i < countof (fcd->ucs_to_mule_table); i++)
fcd->ucs_to_mule_table[i] = Qnil;
}
staticpro (&mule_to_ucs_table);
projects / chise / xemacs-chise.git.1 / blobdiff