#ifdef MULE
struct detection_state;
static int detect_coding_sjis (struct detection_state *st,
- const Extbyte *src, size_t n);
+ const Extbyte *src, Lstream_data_count n);
static void decode_coding_sjis (Lstream *decoding, const Extbyte *src,
- unsigned_char_dynarr *dst, size_t n);
+ unsigned_char_dynarr *dst, Lstream_data_count n);
static void encode_coding_sjis (Lstream *encoding, const Bufbyte *src,
- unsigned_char_dynarr *dst, size_t n);
+ unsigned_char_dynarr *dst, Lstream_data_count n);
static int detect_coding_big5 (struct detection_state *st,
- const Extbyte *src, size_t n);
+ const Extbyte *src, Lstream_data_count n);
static void decode_coding_big5 (Lstream *decoding, const Extbyte *src,
- unsigned_char_dynarr *dst, size_t n);
+ unsigned_char_dynarr *dst, Lstream_data_count n);
static void encode_coding_big5 (Lstream *encoding, const Bufbyte *src,
- unsigned_char_dynarr *dst, size_t n);
+ unsigned_char_dynarr *dst, Lstream_data_count n);
static int detect_coding_ucs4 (struct detection_state *st,
- const Extbyte *src, size_t n);
+ const Extbyte *src, Lstream_data_count n);
static void decode_coding_ucs4 (Lstream *decoding, const Extbyte *src,
- unsigned_char_dynarr *dst, size_t n);
+ unsigned_char_dynarr *dst, Lstream_data_count n);
static void encode_coding_ucs4 (Lstream *encoding, const Bufbyte *src,
- unsigned_char_dynarr *dst, size_t n);
+ unsigned_char_dynarr *dst, Lstream_data_count n);
static int detect_coding_utf8 (struct detection_state *st,
- const Extbyte *src, size_t n);
+ const Extbyte *src, Lstream_data_count n);
static void decode_coding_utf8 (Lstream *decoding, const Extbyte *src,
- unsigned_char_dynarr *dst, size_t n);
+ unsigned_char_dynarr *dst, Lstream_data_count n);
static void encode_coding_utf8 (Lstream *encoding, const Bufbyte *src,
- unsigned_char_dynarr *dst, size_t n);
+ 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 Extbyte *src, size_t n);
+ const Extbyte *src, Lstream_data_count n);
static void decode_coding_iso2022 (Lstream *decoding, const Extbyte *src,
- unsigned_char_dynarr *dst, size_t n);
+ unsigned_char_dynarr *dst, Lstream_data_count n);
static void encode_coding_iso2022 (Lstream *encoding, const Bufbyte *src,
- unsigned_char_dynarr *dst, size_t n);
+ unsigned_char_dynarr *dst, Lstream_data_count n);
#endif /* MULE */
static void decode_coding_no_conversion (Lstream *decoding, const Extbyte *src,
- unsigned_char_dynarr *dst, size_t n);
+ unsigned_char_dynarr *dst, Lstream_data_count n);
static void encode_coding_no_conversion (Lstream *encoding, const Bufbyte *src,
- unsigned_char_dynarr *dst, size_t n);
+ unsigned_char_dynarr *dst, Lstream_data_count n);
static void mule_decode (Lstream *decoding, const Extbyte *src,
- unsigned_char_dynarr *dst, size_t n);
+ unsigned_char_dynarr *dst, Lstream_data_count n);
static void mule_encode (Lstream *encoding, const Bufbyte *src,
- unsigned_char_dynarr *dst, size_t n);
+ 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;
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 (); return Qnil;
+ 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 */
}
static eol_type_t
detect_eol_type (struct detection_state *st, const Extbyte *src,
- size_t n)
+ Lstream_data_count n)
{
while (n--)
{
static int
detect_coding_type (struct detection_state *st, const Extbyte *src,
- size_t n, int just_do_eol)
+ Lstream_data_count n, int just_do_eol)
{
if (st->eol_type == EOL_AUTODETECT)
st->eol_type = detect_eol_type (st, src, n);
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
while (1)
{
Extbyte random_buffer[4096];
- ssize_t nread = Lstream_read (istr, random_buffer, sizeof (random_buffer));
+ Lstream_data_count nread = Lstream_read (istr, random_buffer, sizeof (random_buffer));
if (!nread)
break;
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;
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
static void
mule_decode (Lstream *decoding, const Extbyte *src,
- unsigned_char_dynarr *dst, size_t n)
+ unsigned_char_dynarr *dst, Lstream_data_count n)
{
struct decoding_stream *str = DECODING_STREAM_DATA (decoding);
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
static void
mule_encode (Lstream *encoding, const Bufbyte *src,
- unsigned_char_dynarr *dst, size_t n)
+ unsigned_char_dynarr *dst, Lstream_data_count n)
{
struct encoding_stream *str = ENCODING_STREAM_DATA (encoding);
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 Extbyte *src, size_t n)
+detect_coding_sjis (struct detection_state *st, const Extbyte *src, Lstream_data_count n)
{
while (n--)
{
static void
decode_coding_sjis (Lstream *decoding, const Extbyte *src,
- unsigned_char_dynarr *dst, size_t n)
+ unsigned_char_dynarr *dst, Lstream_data_count n)
{
struct decoding_stream *str = DECODING_STREAM_DATA (decoding);
unsigned int flags = str->flags;
static void
encode_coding_sjis (Lstream *encoding, const Bufbyte *src,
- unsigned_char_dynarr *dst, size_t n)
+ unsigned_char_dynarr *dst, Lstream_data_count n)
{
struct encoding_stream *str = ENCODING_STREAM_DATA (encoding);
unsigned int flags = str->flags;
} while (0)
static int
-detect_coding_big5 (struct detection_state *st, const Extbyte *src, size_t n)
+detect_coding_big5 (struct detection_state *st, const Extbyte *src, Lstream_data_count n)
{
while (n--)
{
static void
decode_coding_big5 (Lstream *decoding, const Extbyte *src,
- unsigned_char_dynarr *dst, size_t n)
+ unsigned_char_dynarr *dst, Lstream_data_count n)
{
struct decoding_stream *str = DECODING_STREAM_DATA (decoding);
unsigned int flags = str->flags;
static void
encode_coding_big5 (Lstream *encoding, const Bufbyte *src,
- unsigned_char_dynarr *dst, size_t n)
+ unsigned_char_dynarr *dst, Lstream_data_count n)
{
unsigned char c;
struct encoding_stream *str = ENCODING_STREAM_DATA (encoding);
}
static int
-detect_coding_ucs4 (struct detection_state *st, const Extbyte *src, size_t n)
+detect_coding_ucs4 (struct detection_state *st, const Extbyte *src, Lstream_data_count n)
{
while (n--)
{
static void
decode_coding_ucs4 (Lstream *decoding, const Extbyte *src,
- unsigned_char_dynarr *dst, size_t n)
+ unsigned_char_dynarr *dst, Lstream_data_count n)
{
struct decoding_stream *str = DECODING_STREAM_DATA (decoding);
unsigned int flags = str->flags;
static void
encode_coding_ucs4 (Lstream *encoding, const Bufbyte *src,
- unsigned_char_dynarr *dst, size_t n)
+ 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 ();
}
}
}
/************************************************************************/
static int
-detect_coding_utf8 (struct detection_state *st, const Extbyte *src, size_t n)
+detect_coding_utf8 (struct detection_state *st, const Extbyte *src, Lstream_data_count n)
{
while (n--)
{
static void
decode_coding_utf8 (Lstream *decoding, const Extbyte *src,
- unsigned_char_dynarr *dst, size_t n)
+ unsigned_char_dynarr *dst, Lstream_data_count n)
{
struct decoding_stream *str = DECODING_STREAM_DATA (decoding);
unsigned int flags = str->flags;
static void
encode_coding_utf8 (Lstream *encoding, const Bufbyte *src,
- unsigned_char_dynarr *dst, size_t n)
+ 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 ();
}
}
}
else
{
/* Can this ever be reached? -slb */
- abort();
+ ABORT();
return 0;
}
}
static int
-detect_coding_iso2022 (struct detection_state *st, const Extbyte *src, size_t n)
+detect_coding_iso2022 (struct detection_state *st, const Extbyte *src, Lstream_data_count n)
{
int mask;
static void
decode_coding_iso2022 (Lstream *decoding, const Extbyte *src,
- unsigned_char_dynarr *dst, size_t n)
+ unsigned_char_dynarr *dst, Lstream_data_count n)
{
struct decoding_stream *str = DECODING_STREAM_DATA (decoding);
unsigned int flags = str->flags;
static void
encode_coding_iso2022 (Lstream *encoding, const Bufbyte *src,
- unsigned_char_dynarr *dst, size_t n)
+ 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 ();
}
}
}
interpreted as being in any particular decoding. */
static void
decode_coding_no_conversion (Lstream *decoding, const Extbyte *src,
- unsigned_char_dynarr *dst, size_t n)
+ unsigned_char_dynarr *dst, Lstream_data_count n)
{
struct decoding_stream *str = DECODING_STREAM_DATA (decoding);
unsigned int flags = str->flags;
static void
encode_coding_no_conversion (Lstream *encoding, const Bufbyte *src,
- unsigned_char_dynarr *dst, size_t n)
+ unsigned_char_dynarr *dst, Lstream_data_count n)
{
unsigned char c;
struct encoding_stream *str = ENCODING_STREAM_DATA (encoding);
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++)
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 \
{ \
projects / chise / xemacs-chise.git.1 / blobdiff