/* Code conversion functions.
Copyright (C) 1991, 1995 Free Software Foundation, Inc.
Copyright (C) 1995 Sun Microsystems, Inc.
+ Copyright (C) 1999,2000 MORIOKA Tomohiko
This file is part of XEmacs.
#endif
#include "file-coding.h"
-Lisp_Object Qbuffer_file_coding_system, Qcoding_system_error;
+Lisp_Object Qcoding_system_error;
Lisp_Object Vkeyboard_coding_system;
Lisp_Object Vterminal_coding_system;
/* Table of symbols identifying each coding category. */
Lisp_Object coding_category_symbol[CODING_CATEGORY_LAST + 1];
-/* Coding system currently associated with each coding category. */
-Lisp_Object coding_category_system[CODING_CATEGORY_LAST + 1];
-/* 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];
-Lisp_Object Qcoding_system_p;
+struct file_coding_dump {
+ /* Coding system currently associated with each coding category. */
+ Lisp_Object coding_category_system[CODING_CATEGORY_LAST + 1];
+
+ /* 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];
+
+#ifndef UTF2000
+ Lisp_Object ucs_to_mule_table[65536];
+#endif
+} *fcd;
+
+static const struct lrecord_description fcd_description_1[] = {
+ { XD_LISP_OBJECT, offsetof(struct file_coding_dump, coding_category_system), CODING_CATEGORY_LAST + 1 },
+#ifndef UTF2000
+ { XD_LISP_OBJECT, offsetof(struct file_coding_dump, ucs_to_mule_table), 65536 },
+#endif
+ { XD_END }
+};
+
+static const struct struct_description fcd_description = {
+ sizeof(struct file_coding_dump),
+ fcd_description_1
+};
+
+Lisp_Object mule_to_ucs_table;
+
+Lisp_Object Qcoding_systemp;
Lisp_Object Qraw_text, Qno_conversion, Qccl, Qiso2022;
/* Qinternal in general.c */
Lisp_Object Qctext, Qescape_quoted;
Lisp_Object Qshort, Qno_ascii_eol, Qno_ascii_cntl, Qseven, Qlock_shift;
#endif
+#ifdef UTF2000
+Lisp_Object Qdisable_composition;
+#endif
Lisp_Object Qencode, Qdecode;
Lisp_Object Vcoding_system_hash_table;
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);
+void char_encode_shift_jis (struct encoding_stream *str, Emchar c,
+ unsigned_char_dynarr *dst, unsigned int *flags);
+void char_finish_shift_jis (struct encoding_stream *str,
+ unsigned_char_dynarr *dst, unsigned int *flags);
+
static int detect_coding_big5 (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);
+void char_encode_ucs4 (struct encoding_stream *str, Emchar c,
+ unsigned_char_dynarr *dst, unsigned int *flags);
+void char_finish_ucs4 (struct encoding_stream *str,
+ unsigned_char_dynarr *dst, unsigned int *flags);
+
static int detect_coding_utf8 (struct detection_state *st,
CONST unsigned char *src,
unsigned int n);
Dynarr_declare (codesys_prop);
} codesys_prop_dynarr;
+static const struct lrecord_description codesys_prop_description_1[] = {
+ { XD_LISP_OBJECT, offsetof(codesys_prop, sym), 1 },
+ { XD_END }
+};
+
+static const struct struct_description codesys_prop_description = {
+ sizeof(codesys_prop),
+ codesys_prop_description_1
+};
+
+static const struct lrecord_description codesys_prop_dynarr_description_1[] = {
+ XD_DYNARR_DESC(codesys_prop_dynarr, &codesys_prop_description),
+ { XD_END }
+};
+
+static const struct struct_description codesys_prop_dynarr_description = {
+ sizeof(codesys_prop_dynarr),
+ codesys_prop_dynarr_description_1
+};
+
codesys_prop_dynarr *the_codesys_prop_dynarr;
enum codesys_prop_enum
/* Coding system functions */
/************************************************************************/
-static Lisp_Object mark_coding_system (Lisp_Object, void (*) (Lisp_Object));
+static Lisp_Object mark_coding_system (Lisp_Object);
static void print_coding_system (Lisp_Object, Lisp_Object, int);
static void finalize_coding_system (void *header, int for_disksave);
sizeof(charset_conversion_spec),
ccs_description_1
};
-
+
static const struct lrecord_description ccsd_description_1[] = {
XD_DYNARR_DESC(charset_conversion_spec_dynarr, &ccs_description),
{ XD_END }
struct Lisp_Coding_System);
static Lisp_Object
-mark_coding_system (Lisp_Object obj, void (*markobj) (Lisp_Object))
+mark_coding_system (Lisp_Object obj)
{
Lisp_Coding_System *codesys = XCODING_SYSTEM (obj);
- markobj (CODING_SYSTEM_NAME (codesys));
- markobj (CODING_SYSTEM_DOC_STRING (codesys));
- markobj (CODING_SYSTEM_MNEMONIC (codesys));
- markobj (CODING_SYSTEM_EOL_LF (codesys));
- markobj (CODING_SYSTEM_EOL_CRLF (codesys));
- markobj (CODING_SYSTEM_EOL_CR (codesys));
+ mark_object (CODING_SYSTEM_NAME (codesys));
+ mark_object (CODING_SYSTEM_DOC_STRING (codesys));
+ mark_object (CODING_SYSTEM_MNEMONIC (codesys));
+ mark_object (CODING_SYSTEM_EOL_LF (codesys));
+ mark_object (CODING_SYSTEM_EOL_CRLF (codesys));
+ mark_object (CODING_SYSTEM_EOL_CR (codesys));
switch (CODING_SYSTEM_TYPE (codesys))
{
int i;
case CODESYS_ISO2022:
for (i = 0; i < 4; i++)
- markobj (CODING_SYSTEM_ISO2022_INITIAL_CHARSET (codesys, i));
+ mark_object (CODING_SYSTEM_ISO2022_INITIAL_CHARSET (codesys, i));
if (codesys->iso2022.input_conv)
{
for (i = 0; i < Dynarr_length (codesys->iso2022.input_conv); i++)
{
struct charset_conversion_spec *ccs =
Dynarr_atp (codesys->iso2022.input_conv, i);
- markobj (ccs->from_charset);
- markobj (ccs->to_charset);
+ mark_object (ccs->from_charset);
+ mark_object (ccs->to_charset);
}
}
if (codesys->iso2022.output_conv)
{
struct charset_conversion_spec *ccs =
Dynarr_atp (codesys->iso2022.output_conv, i);
- markobj (ccs->from_charset);
- markobj (ccs->to_charset);
+ mark_object (ccs->from_charset);
+ mark_object (ccs->to_charset);
}
}
break;
case CODESYS_CCL:
- markobj (CODING_SYSTEM_CCL_DECODE (codesys));
- markobj (CODING_SYSTEM_CCL_ENCODE (codesys));
+ mark_object (CODING_SYSTEM_CCL_DECODE (codesys));
+ mark_object (CODING_SYSTEM_CCL_ENCODE (codesys));
break;
#endif /* MULE */
default:
break;
}
- markobj (CODING_SYSTEM_PRE_WRITE_CONVERSION (codesys));
+ mark_object (CODING_SYSTEM_PRE_WRITE_CONVERSION (codesys));
return CODING_SYSTEM_POST_READ_CONVERSION (codesys);
}
(struct coding_system_list_closure *) coding_system_list_closure;
Lisp_Object *coding_system_list = cscl->coding_system_list;
- *coding_system_list = Fcons (XCODING_SYSTEM (value)->name,
- *coding_system_list);
+ *coding_system_list = Fcons (key, *coding_system_list);
return 0;
}
signal_simple_error ("Invalid charset conversion spec", car);
from = Fget_charset (XCAR (car));
to = Fget_charset (XCAR (XCDR (car)));
- if (XCHARSET_TYPE (from) != XCHARSET_TYPE (to))
+ if ( (XCHARSET_CHARS (from) != XCHARSET_CHARS (to)) ||
+ (XCHARSET_DIMENSION (from) != XCHARSET_DIMENSION (to)) )
signal_simple_error_2
("Attempted conversion between different charset types",
from, to);
converted to nil when stored internally, and
`coding-system-property' will return nil.)
+'disable-composition
+ If non-nil, composition/decomposition for combining characters
+ are disabled.
+
'post-read-conversion
Function called after a file has been read in, to perform the
decoding. Called with two arguments, BEG and END, denoting
CHECK_STRING (doc_string);
CODING_SYSTEM_DOC_STRING (codesys) = doc_string;
-#ifdef UTF2000
- if (ty == CODESYS_NO_CONVERSION)
- codesys->fixed.size = 1;
-#endif
EXTERNAL_PROPERTY_LIST_LOOP (rest, key, value, props)
{
if (EQ (key, Qmnemonic))
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 UTF2000
+ else if (EQ (key, Qdisable_composition))
+ CODING_SYSTEM_DISABLE_COMPOSITION (codesys) = !NILP (value);
+#endif
#ifdef MULE
else if (ty == CODESYS_ISO2022)
{
FROB (CR, "-mac");
#undef FROB
}
- /* FSF return value is a vector of [ALIAS-unix ALIAS-doc ALIAS-mac],
+ /* FSF return value is a vector of [ALIAS-unix ALIAS-dos ALIAS-mac],
but it doesn't look intentional, so I'd rather return something
meaningful or nothing at all. */
return Qnil;
order. */
for (j = 0; j <= CODING_CATEGORY_LAST; j++)
{
- int cat = coding_category_by_priority[j];
+ int cat = fcd->coding_category_by_priority[j];
if (category_to_priority[cat] < 0)
category_to_priority[cat] = i++;
}
constructed. */
for (i = 0; i <= CODING_CATEGORY_LAST; i++)
- coding_category_by_priority[category_to_priority[i]] = i;
+ fcd->coding_category_by_priority[category_to_priority[i]] = i;
/* Phew! That was confusing. */
return Qnil;
Lisp_Object list = Qnil;
for (i = CODING_CATEGORY_LAST; i >= 0; i--)
- list = Fcons (coding_category_symbol[coding_category_by_priority[i]],
+ list = Fcons (coding_category_symbol[fcd->coding_category_by_priority[i]],
list);
return list;
}
int cat = decode_coding_category (coding_category);
coding_system = Fget_coding_system (coding_system);
- coding_category_system[cat] = coding_system;
+ fcd->coding_category_system[cat] = coding_system;
return Qnil;
}
(coding_category))
{
int cat = decode_coding_category (coding_category);
- Lisp_Object sys = coding_category_system[cat];
+ Lisp_Object sys = fcd->coding_category_system[cat];
if (!NILP (sys))
return XCODING_SYSTEM_NAME (sys);
while (n--)
{
c = *src++;
- if (c == '\r')
- st->eol.just_saw_cr = 1;
- else
+ if (c == '\n')
{
- if (c == '\n')
- {
- if (st->eol.just_saw_cr)
- return EOL_CRLF;
- else if (st->eol.seen_anything)
- return EOL_LF;
- }
- else if (st->eol.just_saw_cr)
- return EOL_CR;
- st->eol.just_saw_cr = 0;
+ if (st->eol.just_saw_cr)
+ return EOL_CRLF;
+ else if (st->eol.seen_anything)
+ return EOL_LF;
}
+ else if (st->eol.just_saw_cr)
+ return EOL_CR;
+ else if (c == '\r')
+ st->eol.just_saw_cr = 1;
+ else
+ st->eol.just_saw_cr = 0;
st->eol.seen_anything = 1;
}
*/
static int
-detect_coding_type (struct detection_state *st, CONST unsigned char *src,
+detect_coding_type (struct detection_state *st, CONST Extbyte *src,
unsigned int n, int just_do_eol)
{
int c;
the first one that is allowed. */
for (i = 0; i <= CODING_CATEGORY_LAST; i++)
{
- cat = coding_category_by_priority[i];
+ cat = fcd->coding_category_by_priority[i];
if ((mask & (1 << cat)) &&
- !NILP (coding_category_system[cat]))
+ !NILP (fcd->coding_category_system[cat]))
break;
}
if (cat >= 0)
- return coding_category_system[cat];
+ return fcd->coding_category_system[cat];
else
return Fget_coding_system (Qraw_text);
}
/* Given a seekable read stream and potential coding system and EOL type
as specified, do any autodetection that is called for. If the
- coding system and/or EOL type are not autodetect, they will be left
+ coding system and/or EOL type are not `autodetect', they will be left
alone; but this function will never return an autodetect coding system
or EOL type.
This function does not automatically fetch subsidiary coding systems;
that should be unnecessary with the explicit eol-type argument. */
+#define LENGTH(string_constant) (sizeof (string_constant) - 1)
+
void
determine_real_coding_system (Lstream *stream, Lisp_Object *codesys_in_out,
enum eol_type *eol_type_in_out)
decst.mask = ~0;
/* If autodetection is called for, do it now. */
- if (XCODING_SYSTEM_TYPE (*codesys_in_out) == CODESYS_AUTODETECT ||
- *eol_type_in_out == EOL_AUTODETECT)
+ if (XCODING_SYSTEM_TYPE (*codesys_in_out) == CODESYS_AUTODETECT
+ || *eol_type_in_out == EOL_AUTODETECT)
{
- unsigned char random_buffer[4096];
- int nread;
+ Extbyte buf[4096];
Lisp_Object coding_system = Qnil;
-
- nread = Lstream_read (stream, random_buffer, sizeof (random_buffer));
- if (nread)
- {
- unsigned char *cp = random_buffer;
-
- while (cp < random_buffer + nread)
- {
- if ((*cp++ == 'c') && (cp < random_buffer + nread) &&
- (*cp++ == 'o') && (cp < random_buffer + nread) &&
- (*cp++ == 'd') && (cp < random_buffer + nread) &&
- (*cp++ == 'i') && (cp < random_buffer + nread) &&
- (*cp++ == 'n') && (cp < random_buffer + nread) &&
- (*cp++ == 'g') && (cp < random_buffer + nread) &&
- (*cp++ == ':') && (cp < random_buffer + nread))
+ Extbyte *p;
+ ssize_t nread = Lstream_read (stream, buf, sizeof (buf));
+ Extbyte *scan_end;
+
+ /* Look for initial "-*-"; mode line prefix */
+ for (p = buf,
+ scan_end = buf + nread - LENGTH ("-*-coding:?-*-");
+ p <= scan_end
+ && *p != '\n'
+ && *p != '\r';
+ p++)
+ if (*p == '-' && *(p+1) == '*' && *(p+2) == '-')
+ {
+ Extbyte *local_vars_beg = p + 3;
+ /* Look for final "-*-"; mode line suffix */
+ for (p = local_vars_beg,
+ scan_end = buf + nread - LENGTH ("-*-");
+ p <= scan_end
+ && *p != '\n'
+ && *p != '\r';
+ p++)
+ if (*p == '-' && *(p+1) == '*' && *(p+2) == '-')
{
- unsigned char coding_system_name[4096 - 6];
- unsigned char *np = coding_system_name;
-
- while ( (cp < random_buffer + nread)
- && ((*cp == ' ') || (*cp == '\t')) )
- {
- cp++;
- }
- while ( (cp < random_buffer + nread) &&
- (*cp != ' ') && (*cp != '\t') && (*cp != ';') )
- {
- *np++ = *cp++;
- }
- *np = 0;
- coding_system
- = Ffind_coding_system (intern (coding_system_name));
+ Extbyte *suffix = p;
+ /* Look for "coding:" */
+ for (p = local_vars_beg,
+ scan_end = suffix - LENGTH ("coding:?");
+ p <= scan_end;
+ p++)
+ if (memcmp ("coding:", p, LENGTH ("coding:")) == 0
+ && (p == local_vars_beg
+ || (*(p-1) == ' ' ||
+ *(p-1) == '\t' ||
+ *(p-1) == ';')))
+ {
+ Extbyte save;
+ int n;
+ p += LENGTH ("coding:");
+ while (*p == ' ' || *p == '\t') p++;
+
+ /* Get coding system name */
+ save = *suffix; *suffix = '\0';
+ /* Characters valid in a MIME charset name (rfc 1521),
+ and in a Lisp symbol name. */
+ n = strspn ( (char *) p,
+ "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
+ "abcdefghijklmnopqrstuvwxyz"
+ "0123456789"
+ "!$%&*+-.^_{|}~");
+ *suffix = save;
+ if (n > 0)
+ {
+ save = p[n]; p[n] = '\0';
+ coding_system =
+ Ffind_coding_system (intern ((char *) p));
+ p[n] = save;
+ }
+ break;
+ }
break;
}
- }
- if (EQ(coding_system, Qnil))
- do{
- if (detect_coding_type (&decst, random_buffer, nread,
- XCODING_SYSTEM_TYPE (*codesys_in_out)
- != CODESYS_AUTODETECT))
- break;
- nread = Lstream_read (stream,
- random_buffer, sizeof (random_buffer));
- if (!nread)
- break;
- } while(1);
- }
+ break;
+ }
+
+ if (NILP (coding_system))
+ do
+ {
+ if (detect_coding_type (&decst, buf, nread,
+ XCODING_SYSTEM_TYPE (*codesys_in_out)
+ != CODESYS_AUTODETECT))
+ break;
+ nread = Lstream_read (stream, buf, sizeof (buf));
+ if (nread == 0)
+ break;
+ }
+ while (1);
+
+ else if (XCODING_SYSTEM_TYPE (*codesys_in_out) == CODESYS_AUTODETECT
+ && XCODING_SYSTEM_EOL_TYPE (coding_system) == EOL_AUTODETECT)
+ do
+ {
+ if (detect_coding_type (&decst, buf, nread, 1))
+ break;
+ nread = Lstream_read (stream, buf, sizeof (buf));
+ if (!nread)
+ break;
+ }
+ while (1);
+
*eol_type_in_out = decst.eol_type;
if (XCODING_SYSTEM_TYPE (*codesys_in_out) == CODESYS_AUTODETECT)
{
- if (EQ(coding_system, Qnil))
+ if (NILP (coding_system))
*codesys_in_out = coding_system_from_mask (decst.mask);
else
*codesys_in_out = coding_system;
}
}
+
/* If we absolutely can't determine the EOL type, just assume LF. */
if (*eol_type_in_out == EOL_AUTODETECT)
*eol_type_in_out = EOL_LF;
while (1)
{
unsigned char random_buffer[4096];
- int nread = Lstream_read (istr, random_buffer, sizeof (random_buffer));
+ ssize_t nread = Lstream_read (istr, random_buffer, sizeof (random_buffer));
if (!nread)
break;
#endif
for (i = CODING_CATEGORY_LAST; i >= 0; i--)
{
- int sys = coding_category_by_priority[i];
+ int sys = fcd->coding_category_by_priority[i];
if (decst.mask & (1 << sys))
{
- Lisp_Object codesys = coding_category_system[sys];
+ Lisp_Object codesys = fcd->coding_category_system[sys];
if (!NILP (codesys))
codesys = subsidiary_coding_system (codesys, decst.eol_type);
val = Fcons (codesys, val);
/* counter for UTF-8 or UCS-4 */
unsigned char counter;
#endif
+#ifdef UTF2000
+ unsigned combined_char_count;
+ Emchar combined_chars[16];
+ Lisp_Object combining_table;
+#endif
struct detection_state decst;
};
-static int decoding_reader (Lstream *stream, unsigned char *data, size_t size);
-static int decoding_writer (Lstream *stream, CONST unsigned char *data, size_t size);
+#ifdef UTF2000
+extern Lisp_Object Vcharacter_composition_table;
+
+INLINE void
+COMPOSE_FLUSH_CHARS (struct decoding_stream *str, unsigned_char_dynarr* dst)
+{
+ unsigned i;
+
+ for (i = 0; i < str->combined_char_count; i++)
+ DECODE_ADD_UCS_CHAR (str->combined_chars[i], dst);
+ str->combined_char_count = 0;
+ str->combining_table = Qnil;
+}
+
+void
+COMPOSE_ADD_CHAR(struct decoding_stream *str,
+ Emchar character, unsigned_char_dynarr* dst)
+{
+ if (CODING_SYSTEM_DISABLE_COMPOSITION (str->codesys))
+ DECODE_ADD_UCS_CHAR (character, dst);
+ else if (!CHAR_CODE_TABLE_P (str->combining_table))
+ {
+ Lisp_Object ret
+ = get_char_code_table (character, Vcharacter_composition_table);
+
+ if (NILP (ret))
+ DECODE_ADD_UCS_CHAR (character, dst);
+ else
+ {
+ str->combined_chars[0] = character;
+ str->combined_char_count = 1;
+ str->combining_table = ret;
+ }
+ }
+ else
+ {
+ Lisp_Object ret
+ = get_char_code_table (character, str->combining_table);
+
+ if (CHARP (ret))
+ {
+ Emchar char2 = XCHARVAL (ret);
+ ret = get_char_code_table (char2, Vcharacter_composition_table);
+ if (NILP (ret))
+ {
+ DECODE_ADD_UCS_CHAR (char2, dst);
+ str->combined_char_count = 0;
+ str->combining_table = Qnil;
+ }
+ else
+ {
+ str->combined_chars[0] = char2;
+ str->combined_char_count = 1;
+ str->combining_table = ret;
+ }
+ }
+ else if (CHAR_CODE_TABLE_P (ret))
+ {
+ str->combined_chars[str->combined_char_count++] = character;
+ str->combining_table = ret;
+ }
+ else
+ {
+ COMPOSE_FLUSH_CHARS (str, dst);
+ DECODE_ADD_UCS_CHAR (character, dst);
+ }
+ }
+}
+#else /* not UTF2000 */
+#define COMPOSE_FLUSH_CHARS(str, dst)
+#define COMPOSE_ADD_CHAR(str, ch, dst) DECODE_ADD_UCS_CHAR (ch, dst)
+#endif /* UTF2000 */
+
+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 int decoding_rewinder (Lstream *stream);
static int decoding_seekable_p (Lstream *stream);
static int decoding_flusher (Lstream *stream);
static int decoding_closer (Lstream *stream);
-static Lisp_Object decoding_marker (Lisp_Object stream,
- void (*markobj) (Lisp_Object));
+static Lisp_Object decoding_marker (Lisp_Object stream);
DEFINE_LSTREAM_IMPLEMENTATION ("decoding", lstream_decoding,
sizeof (struct decoding_stream));
static Lisp_Object
-decoding_marker (Lisp_Object stream, void (*markobj) (Lisp_Object))
+decoding_marker (Lisp_Object stream)
{
Lstream *str = DECODING_STREAM_DATA (XLSTREAM (stream))->other_end;
Lisp_Object str_obj;
and automatically marked. */
XSETLSTREAM (str_obj, str);
- markobj (str_obj);
+ mark_object (str_obj);
if (str->imp->marker)
- return (str->imp->marker) (str_obj, markobj);
+ return (str->imp->marker) (str_obj);
else
return Qnil;
}
/* 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 int
+static ssize_t
decoding_reader (Lstream *stream, unsigned char *data, size_t size)
{
struct decoding_stream *str = DECODING_STREAM_DATA (stream);
unsigned char *orig_data = data;
- int read_size;
+ ssize_t read_size;
int error_occurred = 0;
/* We need to interface to mule_decode(), which expects to take some
return data - orig_data;
}
-static int
+static ssize_t
decoding_writer (Lstream *stream, CONST unsigned char *data, size_t size)
{
struct decoding_stream *str = DECODING_STREAM_DATA (stream);
- int retval;
+ ssize_t 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
}
str->counter = 0;
#endif /* MULE */
+#ifdef UTF2000
+ str->combined_char_count = 0;
+ str->combining_table = Qnil;
+#endif
str->flags = str->ch = 0;
}
char tempbuf[1024]; /* some random amount */
Bufpos newpos, even_newer_pos;
Bufpos oldpos = lisp_buffer_stream_startpos (istr);
- int size_in_bytes = Lstream_read (istr, tempbuf, sizeof (tempbuf));
+ ssize_t size_in_bytes = Lstream_read (istr, tempbuf, sizeof (tempbuf));
if (!size_in_bytes)
break;
#endif /* MULE */
};
-static int encoding_reader (Lstream *stream, unsigned char *data, size_t size);
-static int encoding_writer (Lstream *stream, CONST unsigned char *data,
- size_t size);
+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 int encoding_rewinder (Lstream *stream);
static int encoding_seekable_p (Lstream *stream);
static int encoding_flusher (Lstream *stream);
static int encoding_closer (Lstream *stream);
-static Lisp_Object encoding_marker (Lisp_Object stream,
- void (*markobj) (Lisp_Object));
+static Lisp_Object encoding_marker (Lisp_Object stream);
DEFINE_LSTREAM_IMPLEMENTATION ("encoding", lstream_encoding,
sizeof (struct encoding_stream));
static Lisp_Object
-encoding_marker (Lisp_Object stream, void (*markobj) (Lisp_Object))
+encoding_marker (Lisp_Object stream)
{
Lstream *str = ENCODING_STREAM_DATA (XLSTREAM (stream))->other_end;
Lisp_Object str_obj;
and automatically marked. */
XSETLSTREAM (str_obj, str);
- markobj (str_obj);
+ mark_object (str_obj);
if (str->imp->marker)
- return (str->imp->marker) (str_obj, markobj);
+ return (str->imp->marker) (str_obj);
else
return Qnil;
}
/* 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 int
+static ssize_t
encoding_reader (Lstream *stream, unsigned char *data, size_t size)
{
struct encoding_stream *str = ENCODING_STREAM_DATA (stream);
unsigned char *orig_data = data;
- int read_size;
+ ssize_t read_size;
int error_occurred = 0;
/* We need to interface to mule_encode(), which expects to take some
return data - orig_data;
}
-static int
+static ssize_t
encoding_writer (Lstream *stream, CONST unsigned char *data, size_t size)
{
struct encoding_stream *str = ENCODING_STREAM_DATA (stream);
- int retval;
+ ssize_t 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
case CODESYS_UTF8:
str->encode_char = &char_encode_utf8;
str->finish = &char_finish_utf8;
+ break;
+ case CODESYS_UCS4:
+ str->encode_char = &char_encode_ucs4;
+ str->finish = &char_finish_ucs4;
+ break;
+ case CODESYS_SHIFT_JIS:
+ str->encode_char = &char_encode_shift_jis;
+ str->finish = &char_finish_shift_jis;
+ break;
default:
break;
}
encode_coding_no_conversion (encoding, src, dst, n);
break;
#ifdef MULE
- case CODESYS_SHIFT_JIS:
- encode_coding_sjis (encoding, src, dst, n);
- break;
case CODESYS_BIG5:
encode_coding_big5 (encoding, src, dst, n);
break;
- case CODESYS_UCS4:
- encode_coding_ucs4 (encoding, src, dst, n);
- break;
case CODESYS_CCL:
str->ccl.last_block = str->flags & CODING_STATE_END;
ccl_driver (&str->ccl, src, dst, n, 0, CCL_MODE_ENCODING);
char tempbuf[1024]; /* some random amount */
Bufpos newpos, even_newer_pos;
Bufpos oldpos = lisp_buffer_stream_startpos (istr);
- int size_in_bytes = Lstream_read (istr, tempbuf, sizeof (tempbuf));
+ ssize_t size_in_bytes = Lstream_read (istr, tempbuf, sizeof (tempbuf));
if (!size_in_bytes)
break;
struct encoding_stream *str = ENCODING_STREAM_DATA (encoding);
unsigned int flags = str->flags;
Emchar ch = str->ch;
- Lisp_Object charset;
- int half;
char_boundary = str->iso2022.current_char_boundary;
- charset = str->iso2022.current_charset;
- half = str->iso2022.current_half;
while (n--)
{
c = *src++;
- switch (char_boundary)
+ if (char_boundary == 0)
{
- case 0:
- if ( c >= 0xfc )
+ if (c >= 0xfc)
{
ch = c & 0x01;
char_boundary = 5;
}
- else if ( c >= 0xf8 )
+ else if (c >= 0xf8)
{
ch = c & 0x03;
char_boundary = 4;
}
- else if ( c >= 0xf0 )
+ else if (c >= 0xf0)
{
ch = c & 0x07;
char_boundary = 3;
}
- else if ( c >= 0xe0 )
+ else if (c >= 0xe0)
{
ch = c & 0x0f;
char_boundary = 2;
}
- else if ( c >= 0xc0 )
+ else if (c >= 0xc0)
{
ch = c & 0x1f;
char_boundary = 1;
}
else
- {
- (*str->encode_char) (str, c, dst, &flags);
- ch = 0;
- char_boundary = 0;
- }
- break;
- case 1:
+ (*str->encode_char) (str, c, dst, &flags);
+ }
+ else if (char_boundary == 1)
+ {
(*str->encode_char) (str, (ch << 6) | (c & 0x3f), dst, &flags);
ch =0;
char_boundary = 0;
- break;
- default:
- ch = ( ch << 6 ) | ( c & 0x3f );
+ }
+ else
+ {
+ ch = (ch << 6) | (c & 0x3f);
char_boundary--;
}
}
- if ( (char_boundary == 0) && flags & CODING_STATE_END)
+ if ((char_boundary == 0) && (flags & CODING_STATE_END))
{
(*str->finish) (str, dst, &flags);
}
str->flags = flags;
str->ch = ch;
str->iso2022.current_char_boundary = char_boundary;
- str->iso2022.current_charset = charset;
- str->iso2022.current_half = half;
-
- /* Verbum caro factum est! */
}
\f
Dynarr_add (dst, c);
#endif
}
+#ifdef UTF2000
+ else if (c > 32)
+ DECODE_ADD_UCS_CHAR(MAKE_CHAR(Vcharset_latin_jisx0201,
+ c, 0), dst);
+#endif
else
DECODE_ADD_BINARY_CHAR (c, dst);
}
str->ch = ch;
}
-/* Convert internally-formatted data to Shift-JIS. */
+/* Convert internal character representation to Shift_JIS. */
-static void
-encode_coding_sjis (Lstream *encoding, CONST unsigned char *src,
- unsigned_char_dynarr *dst, unsigned int n)
+void
+char_encode_shift_jis (struct encoding_stream *str, Emchar ch,
+ unsigned_char_dynarr *dst, unsigned int *flags)
{
- unsigned char c;
- struct encoding_stream *str = ENCODING_STREAM_DATA (encoding);
- unsigned int flags = str->flags;
- unsigned int ch = str->ch;
eol_type_t eol_type = CODING_SYSTEM_EOL_TYPE (str->codesys);
-#ifdef UTF2000
- unsigned char char_boundary = str->iso2022.current_char_boundary;
-#endif
- while (n--)
+ if (ch == '\n')
{
- c = *src++;
+ if (eol_type != EOL_LF && eol_type != EOL_AUTODETECT)
+ Dynarr_add (dst, '\r');
+ if (eol_type != EOL_CR)
+ Dynarr_add (dst, ch);
+ }
+ else
+ {
+ Lisp_Object charset;
+ unsigned int c1, c2, s1, s2;
#ifdef UTF2000
- switch (char_boundary)
+ int code_point = charset_code_point (Vcharset_latin_jisx0201, ch);
+
+ if (code_point >= 0)
{
- case 0:
- if ( c >= 0xfc )
- {
- ch = c & 0x01;
- char_boundary = 5;
- }
- else if ( c >= 0xf8 )
- {
- ch = c & 0x03;
- char_boundary = 4;
- }
- else if ( c >= 0xf0 )
- {
- ch = c & 0x07;
- char_boundary = 3;
- }
- else if ( c >= 0xe0 )
- {
- ch = c & 0x0f;
- char_boundary = 2;
- }
- else if ( c >= 0xc0 )
- {
- ch = c & 0x1f;
- char_boundary = 1;
- }
- else
- {
- ch = 0;
- if (c == '\n')
- {
- if (eol_type != EOL_LF && eol_type != EOL_AUTODETECT)
- Dynarr_add (dst, '\r');
- if (eol_type != EOL_CR)
- Dynarr_add (dst, c);
- }
- else
- Dynarr_add (dst, c);
- char_boundary = 0;
- }
- break;
- case 1:
- ch = ( ch << 6 ) | ( c & 0x3f );
- {
- Lisp_Object charset;
- unsigned int c1, c2, s1, s2;
-
- BREAKUP_CHAR (ch, charset, c1, c2);
- if (EQ(charset, Vcharset_katakana_jisx0201))
- {
- Dynarr_add (dst, c1 | 0x80);
- }
- else if (EQ(charset, Vcharset_japanese_jisx0208))
- {
- ENCODE_SJIS (c1 | 0x80, c2 | 0x80, s1, s2);
- Dynarr_add (dst, s1);
- Dynarr_add (dst, s2);
- }
- }
- char_boundary = 0;
- break;
- default:
- ch = ( ch << 6 ) | ( c & 0x3f );
- char_boundary--;
+ charset = Vcharset_latin_jisx0201;
+ c1 = code_point;
+ c2 = 0;
}
-#else
- if (c == '\n')
+ else
+#endif
+ BREAKUP_CHAR (ch, charset, c1, c2);
+
+ if (EQ(charset, Vcharset_katakana_jisx0201))
{
- if (eol_type != EOL_LF && eol_type != EOL_AUTODETECT)
- Dynarr_add (dst, '\r');
- if (eol_type != EOL_CR)
- Dynarr_add (dst, '\n');
- ch = 0;
+ Dynarr_add (dst, c1 | 0x80);
}
- else if (BYTE_ASCII_P (c))
+ else if (c2 == 0)
{
- Dynarr_add (dst, c);
- ch = 0;
+ Dynarr_add (dst, c1);
}
- else if (BUFBYTE_LEADING_BYTE_P (c))
- ch = (c == LEADING_BYTE_KATAKANA_JISX0201 ||
- c == LEADING_BYTE_JAPANESE_JISX0208_1978 ||
- c == LEADING_BYTE_JAPANESE_JISX0208) ? c : 0;
- else if (ch)
+ else if (EQ(charset, Vcharset_japanese_jisx0208))
{
- if (ch == LEADING_BYTE_KATAKANA_JISX0201)
- {
- Dynarr_add (dst, c);
- ch = 0;
- }
- else if (ch == LEADING_BYTE_JAPANESE_JISX0208_1978 ||
- ch == LEADING_BYTE_JAPANESE_JISX0208)
- ch = c;
- else
- {
- unsigned char j1, j2;
- ENCODE_SJIS (ch, c, j1, j2);
- Dynarr_add (dst, j1);
- Dynarr_add (dst, j2);
- ch = 0;
- }
+ ENCODE_SJIS (c1 | 0x80, c2 | 0x80, s1, s2);
+ Dynarr_add (dst, s1);
+ Dynarr_add (dst, s2);
}
-#endif
+ else
+ Dynarr_add (dst, '?');
}
+}
- str->flags = flags;
- str->ch = ch;
-#ifdef UTF2000
- str->iso2022.current_char_boundary = char_boundary;
-#endif
+void
+char_finish_shift_jis (struct encoding_stream *str, unsigned_char_dynarr *dst,
+ unsigned int *flags)
+{
}
DEFUN ("decode-shift-jis-char", Fdecode_shift_jis_char, 1, 1, 0, /*
\f
/************************************************************************/
/* UCS-4 methods */
-/* */
-/* UCS-4 character codes are implemented as nonnegative integers. */
-/* */
/************************************************************************/
-Lisp_Object ucs_to_mule_table[65536];
-Lisp_Object mule_to_ucs_table;
-
-DEFUN ("set-ucs-char", Fset_ucs_char, 2, 2, 0, /*
-Map UCS-4 code CODE to Mule character CHARACTER.
-
-Return T on success, NIL on failure.
-*/
- (code, character))
-{
- unsigned int c;
-
- CHECK_CHAR (character);
- CHECK_INT (code);
- c = XINT (code);
-
- if (c < sizeof (ucs_to_mule_table))
- {
- ucs_to_mule_table[c] = character;
- return Qt;
- }
- else
- return Qnil;
-}
-
-static Lisp_Object
-ucs_to_char (unsigned long code)
-{
- if (code < sizeof (ucs_to_mule_table))
- {
- return ucs_to_mule_table[code];
- }
- else if ((0xe00000 <= code) && (code <= 0xe00000 + 94 * 94 * 14))
- {
- unsigned int c;
-
- code -= 0xe00000;
- c = code % (94 * 94);
- return make_char
- (MAKE_CHAR (CHARSET_BY_ATTRIBUTES
- (CHARSET_TYPE_94X94, code / (94 * 94) + '@',
- CHARSET_LEFT_TO_RIGHT),
- c / 94 + 33, c % 94 + 33));
- }
- else
- return Qnil;
-}
-
-DEFUN ("ucs-char", Fucs_char, 1, 1, 0, /*
-Return Mule character corresponding to UCS code CODE (a positive integer).
-*/
- (code))
-{
- CHECK_NATNUM (code);
- return ucs_to_char (XINT (code));
-}
-
-DEFUN ("set-char-ucs", Fset_char_ucs, 2, 2, 0, /*
-Map Mule character CHARACTER to UCS code CODE (a positive integer).
-*/
- (character, code))
-{
- /* #### Isn't this gilding the lily? Fput_char_table checks its args.
- Fset_char_ucs is more restrictive on index arg, but should
- check code arg in a char_table method. */
- CHECK_CHAR (character);
- CHECK_NATNUM (code);
- return Fput_char_table (character, code, mule_to_ucs_table);
-}
-
-DEFUN ("char-ucs", Fchar_ucs, 1, 1, 0, /*
-Return the UCS code (a positive integer) corresponding to CHARACTER.
-*/
- (character))
-{
- return Fget_char_table (character, mule_to_ucs_table);
-}
-
-#ifdef UTF2000
-#define decode_ucs4 DECODE_ADD_UCS_CHAR
-#else
-/* Decode a UCS-4 character into a buffer. If the lookup fails, use
- <GETA MARK> (U+3013) of JIS X 0208, which means correct character
- is not found, instead.
- #### do something more appropriate (use blob?)
- Danger, Will Robinson! Data loss. Should we signal user? */
-static void
-decode_ucs4 (unsigned long ch, unsigned_char_dynarr *dst)
-{
- Lisp_Object chr = ucs_to_char (ch);
-
- if (! NILP (chr))
- {
- Bufbyte work[MAX_EMCHAR_LEN];
- int len;
-
- ch = XCHAR (chr);
- len = (ch < 128) ?
- simple_set_charptr_emchar (work, ch) :
- non_ascii_set_charptr_emchar (work, ch);
- Dynarr_add_many (dst, work, len);
- }
- else
- {
- Dynarr_add (dst, LEADING_BYTE_JAPANESE_JISX0208);
- Dynarr_add (dst, 34 + 128);
- Dynarr_add (dst, 46 + 128);
- }
-}
-#endif
-
-static unsigned long
-mule_char_to_ucs4 (Lisp_Object charset,
- unsigned char h, unsigned char l)
-{
- Lisp_Object code
- = Fget_char_table (make_char (MAKE_CHAR (charset, h & 127, l & 127)),
- mule_to_ucs_table);
-
- if (INTP (code))
- {
- return XINT (code);
- }
- else if ( (XCHARSET_DIMENSION (charset) == 2) &&
- (XCHARSET_CHARS (charset) == 94) )
- {
- unsigned char final = XCHARSET_FINAL (charset);
-
- if ( ('@' <= final) && (final < 0x7f) )
- {
- return 0xe00000 + (final - '@') * 94 * 94
- + ((h & 127) - 33) * 94 + (l & 127) - 33;
- }
- else
- {
- return '?';
- }
- }
- else
- {
- return '?';
- }
-}
-
-static void
-encode_ucs4 (Lisp_Object charset,
- unsigned char h, unsigned char l, unsigned_char_dynarr *dst)
-{
- unsigned long code = mule_char_to_ucs4 (charset, h, l);
- Dynarr_add (dst, code >> 24);
- Dynarr_add (dst, (code >> 16) & 255);
- Dynarr_add (dst, (code >> 8) & 255);
- Dynarr_add (dst, code & 255);
-}
-
static int
detect_coding_ucs4 (struct detection_state *st, CONST unsigned char *src,
unsigned int n)
counter = 3;
break;
case 1:
- decode_ucs4 ( ( ch << 8 ) | c, dst);
+ DECODE_ADD_UCS_CHAR ((ch << 8) | c, dst);
ch = 0;
counter = 0;
break;
str->counter = counter;
}
-static void
-encode_coding_ucs4 (Lstream *encoding, CONST unsigned char *src,
- unsigned_char_dynarr *dst, unsigned int n)
+void
+char_encode_ucs4 (struct encoding_stream *str, Emchar ch,
+ unsigned_char_dynarr *dst, unsigned int *flags)
{
-#ifndef UTF2000
- struct encoding_stream *str = ENCODING_STREAM_DATA (encoding);
- unsigned int flags = str->flags;
- unsigned int ch = str->ch;
- unsigned char char_boundary = str->iso2022.current_char_boundary;
- Lisp_Object charset = str->iso2022.current_charset;
-
-#ifdef ENABLE_COMPOSITE_CHARS
- /* flags for handling composite chars. We do a little switcharoo
- on the source while we're outputting the composite char. */
- unsigned int saved_n = 0;
- CONST unsigned char *saved_src = NULL;
- int in_composite = 0;
-
- back_to_square_n:
-#endif
-
- while (n--)
- {
- unsigned char c = *src++;
-
- if (BYTE_ASCII_P (c))
- { /* Processing ASCII character */
- ch = 0;
- encode_ucs4 (Vcharset_ascii, c, 0, dst);
- char_boundary = 1;
- }
- else if (BUFBYTE_LEADING_BYTE_P (c) || BUFBYTE_LEADING_BYTE_P (ch))
- { /* Processing Leading Byte */
- ch = 0;
- charset = CHARSET_BY_LEADING_BYTE (c);
- if (LEADING_BYTE_PREFIX_P(c))
- ch = c;
- char_boundary = 0;
- }
- else
- { /* Processing Non-ASCII character */
- char_boundary = 1;
- if (EQ (charset, Vcharset_control_1))
- {
- encode_ucs4 (Vcharset_control_1, c, 0, dst);
- }
- else
- {
- switch (XCHARSET_REP_BYTES (charset))
- {
- case 2:
- encode_ucs4 (charset, c, 0, dst);
- break;
- case 3:
- if (XCHARSET_PRIVATE_P (charset))
- {
- encode_ucs4 (charset, c, 0, dst);
- ch = 0;
- }
- else if (ch)
- {
-#ifdef ENABLE_COMPOSITE_CHARS
- if (EQ (charset, Vcharset_composite))
- {
- if (in_composite)
- {
- /* #### 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, '~');
- }
- else
- {
- Emchar emch = MAKE_CHAR (Vcharset_composite,
- ch & 0x7F, c & 0x7F);
- Lisp_Object lstr = composite_char_string (emch);
- saved_n = n;
- saved_src = src;
- in_composite = 1;
- src = XSTRING_DATA (lstr);
- n = XSTRING_LENGTH (lstr);
- }
- }
- else
-#endif /* ENABLE_COMPOSITE_CHARS */
- {
- encode_ucs4(charset, ch, c, dst);
- }
- ch = 0;
- }
- else
- {
- ch = c;
- char_boundary = 0;
- }
- break;
- case 4:
- if (ch)
- {
- encode_ucs4 (charset, ch, c, dst);
- ch = 0;
- }
- else
- {
- ch = c;
- char_boundary = 0;
- }
- break;
- default:
- abort ();
- }
- }
- }
- }
-
-#ifdef ENABLE_COMPOSITE_CHARS
- if (in_composite)
- {
- n = saved_n;
- src = saved_src;
- in_composite = 0;
- goto back_to_square_n; /* Wheeeeeeeee ..... */
- }
-#endif /* ENABLE_COMPOSITE_CHARS */
-
- str->flags = flags;
- str->ch = ch;
- str->iso2022.current_char_boundary = char_boundary;
- str->iso2022.current_charset = charset;
+ Dynarr_add (dst, ch >> 24);
+ Dynarr_add (dst, ch >> 16);
+ Dynarr_add (dst, ch >> 8);
+ Dynarr_add (dst, ch );
+}
- /* Verbum caro factum est! */
-#endif
+void
+char_finish_ucs4 (struct encoding_stream *str, unsigned_char_dynarr *dst,
+ unsigned int *flags)
+{
}
\f
else
{
DECODE_HANDLE_EOL_TYPE (eol_type, c, flags, dst);
- decode_ucs4 (c, dst);
+ DECODE_ADD_UCS_CHAR (c, dst);
}
break;
case 1:
ch = ( ch << 6 ) | ( c & 0x3f );
- decode_ucs4 (ch, dst);
+ DECODE_ADD_UCS_CHAR (ch, dst);
ch = 0;
counter = 0;
break;
}
void
-char_encode_utf8 (struct encoding_stream *str, Emchar code,
+char_encode_utf8 (struct encoding_stream *str, Emchar ch,
unsigned_char_dynarr *dst, unsigned int *flags)
{
- if ( code <= 0x7f )
+ eol_type_t eol_type = CODING_SYSTEM_EOL_TYPE (str->codesys);
+
+ if (ch == '\n')
{
- Dynarr_add (dst, code);
+ if (eol_type != EOL_LF && eol_type != EOL_AUTODETECT)
+ Dynarr_add (dst, '\r');
+ if (eol_type != EOL_CR)
+ Dynarr_add (dst, ch);
}
- else if ( code <= 0x7ff )
+ else if (ch <= 0x7f)
{
- Dynarr_add (dst, (code >> 6) | 0xc0);
- Dynarr_add (dst, (code & 0x3f) | 0x80);
+ Dynarr_add (dst, ch);
}
- else if ( code <= 0xffff )
+ else if (ch <= 0x7ff)
{
- Dynarr_add (dst, (code >> 12) | 0xe0);
- Dynarr_add (dst, ((code >> 6) & 0x3f) | 0x80);
- Dynarr_add (dst, (code & 0x3f) | 0x80);
+ Dynarr_add (dst, (ch >> 6) | 0xc0);
+ Dynarr_add (dst, (ch & 0x3f) | 0x80);
}
- else if ( code <= 0x1fffff )
+ else if (ch <= 0xffff)
{
- Dynarr_add (dst, (code >> 18) | 0xf0);
- Dynarr_add (dst, ((code >> 12) & 0x3f) | 0x80);
- Dynarr_add (dst, ((code >> 6) & 0x3f) | 0x80);
- Dynarr_add (dst, (code & 0x3f) | 0x80);
+ Dynarr_add (dst, (ch >> 12) | 0xe0);
+ Dynarr_add (dst, ((ch >> 6) & 0x3f) | 0x80);
+ Dynarr_add (dst, (ch & 0x3f) | 0x80);
}
- else if ( code <= 0x3ffffff )
+ else if (ch <= 0x1fffff)
{
- Dynarr_add (dst, (code >> 24) | 0xf8);
- Dynarr_add (dst, ((code >> 18) & 0x3f) | 0x80);
- Dynarr_add (dst, ((code >> 12) & 0x3f) | 0x80);
- Dynarr_add (dst, ((code >> 6) & 0x3f) | 0x80);
- Dynarr_add (dst, (code & 0x3f) | 0x80);
+ Dynarr_add (dst, (ch >> 18) | 0xf0);
+ Dynarr_add (dst, ((ch >> 12) & 0x3f) | 0x80);
+ Dynarr_add (dst, ((ch >> 6) & 0x3f) | 0x80);
+ Dynarr_add (dst, (ch & 0x3f) | 0x80);
+ }
+ else if (ch <= 0x3ffffff)
+ {
+ Dynarr_add (dst, (ch >> 24) | 0xf8);
+ Dynarr_add (dst, ((ch >> 18) & 0x3f) | 0x80);
+ Dynarr_add (dst, ((ch >> 12) & 0x3f) | 0x80);
+ Dynarr_add (dst, ((ch >> 6) & 0x3f) | 0x80);
+ Dynarr_add (dst, (ch & 0x3f) | 0x80);
}
else
{
- Dynarr_add (dst, (code >> 30) | 0xfc);
- Dynarr_add (dst, ((code >> 24) & 0x3f) | 0x80);
- Dynarr_add (dst, ((code >> 18) & 0x3f) | 0x80);
- Dynarr_add (dst, ((code >> 12) & 0x3f) | 0x80);
- Dynarr_add (dst, ((code >> 6) & 0x3f) | 0x80);
- Dynarr_add (dst, (code & 0x3f) | 0x80);
+ Dynarr_add (dst, (ch >> 30) | 0xfc);
+ Dynarr_add (dst, ((ch >> 24) & 0x3f) | 0x80);
+ Dynarr_add (dst, ((ch >> 18) & 0x3f) | 0x80);
+ Dynarr_add (dst, ((ch >> 12) & 0x3f) | 0x80);
+ Dynarr_add (dst, ((ch >> 6) & 0x3f) | 0x80);
+ Dynarr_add (dst, (ch & 0x3f) | 0x80);
}
}
#endif /* ENABLE_COMPOSITE_CHARS */
case ISO_ESC_LITERAL:
+ COMPOSE_FLUSH_CHARS (str, dst);
DECODE_ADD_BINARY_CHAR (c, dst);
break;
{
/* Output the (possibly invalid) sequence */
int i;
+ COMPOSE_FLUSH_CHARS (str, dst);
for (i = 0; i < str->iso2022.esc_bytes_index; i++)
DECODE_ADD_BINARY_CHAR (str->iso2022.esc_bytes[i], dst);
flags &= CODING_STATE_ISO2022_LOCK;
/* No sense in reprocessing the final byte of the
escape sequence; it could mess things up anyway.
Just add it now. */
+ COMPOSE_FLUSH_CHARS (str, dst);
DECODE_ADD_BINARY_CHAR (c, dst);
}
}
/* If we were in the middle of a character, dump out the
partial character. */
- DECODE_OUTPUT_PARTIAL_CHAR (ch);
+ if (ch)
+ {
+ COMPOSE_FLUSH_CHARS (str, dst);
+ DECODE_ADD_BINARY_CHAR (ch, dst);
+ ch = 0;
+ }
/* If we just saw a single-shift character, dump it out.
This may dump out the wrong sort of single-shift character,
wrong. */
if (flags & CODING_STATE_SS2)
{
+ COMPOSE_FLUSH_CHARS (str, dst);
DECODE_ADD_BINARY_CHAR (ISO_CODE_SS2, dst);
flags &= ~CODING_STATE_SS2;
}
if (flags & CODING_STATE_SS3)
{
+ COMPOSE_FLUSH_CHARS (str, dst);
DECODE_ADD_BINARY_CHAR (ISO_CODE_SS3, dst);
flags &= ~CODING_STATE_SS3;
}
/***** Now handle the control characters. *****/
/* Handle CR/LF */
+#ifdef UTF2000
+ if (c == '\r')
+ {
+ COMPOSE_FLUSH_CHARS (str, dst);
+ if (eol_type == EOL_CR)
+ Dynarr_add (dst, '\n');
+ else if (eol_type != EOL_CRLF || flags & CODING_STATE_CR)
+ Dynarr_add (dst, c);
+ else
+ flags |= CODING_STATE_CR;
+ goto label_continue_loop;
+ }
+ else if (flags & CODING_STATE_CR)
+ { /* eol_type == CODING_SYSTEM_EOL_CRLF */
+ if (c != '\n')
+ Dynarr_add (dst, '\r');
+ flags &= ~CODING_STATE_CR;
+ }
+#else
DECODE_HANDLE_EOL_TYPE (eol_type, c, flags, dst);
+#endif
flags &= CODING_STATE_ISO2022_LOCK;
if (!parse_iso2022_esc (coding_system, &str->iso2022, c, &flags, 1))
- DECODE_ADD_BINARY_CHAR (c, dst);
+ {
+ COMPOSE_FLUSH_CHARS (str, dst);
+ DECODE_ADD_BINARY_CHAR (c, dst);
+ }
}
else
{ /* Graphic characters */
#endif
int reg;
+#ifdef UTF2000
+ if (c == '\r')
+ {
+ COMPOSE_FLUSH_CHARS (str, dst);
+ if (eol_type == EOL_CR)
+ Dynarr_add (dst, '\n');
+ else if (eol_type != EOL_CRLF || flags & CODING_STATE_CR)
+ Dynarr_add (dst, c);
+ else
+ flags |= CODING_STATE_CR;
+ goto label_continue_loop;
+ }
+ else if (flags & CODING_STATE_CR)
+ { /* eol_type == CODING_SYSTEM_EOL_CRLF */
+ if (c != '\n')
+ Dynarr_add (dst, '\r');
+ flags &= ~CODING_STATE_CR;
+ }
+#else
DECODE_HANDLE_EOL_TYPE (eol_type, c, flags, dst);
+#endif
/* Now determine the charset. */
reg = ((flags & CODING_STATE_SS2) ? 2
outside the range of the charset. Insert that char literally
to preserve it for the output. */
{
+ COMPOSE_FLUSH_CHARS (str, dst);
DECODE_OUTPUT_PARTIAL_CHAR (ch);
DECODE_ADD_BINARY_CHAR (c, dst);
}
charset = new_charset;
}
-#ifndef UTF2000
+#ifdef UTF2000
+ if (XCHARSET_DIMENSION (charset) == 1)
+ {
+ if (ch)
+ {
+ COMPOSE_FLUSH_CHARS (str, dst);
+ DECODE_ADD_BINARY_CHAR (ch, dst);
+ ch = 0;
+ }
+ COMPOSE_ADD_CHAR (str,
+ MAKE_CHAR (charset, c & 0x7F, 0), dst);
+ }
+ else if (ch)
+ {
+ COMPOSE_ADD_CHAR (str,
+ MAKE_CHAR (charset, ch & 0x7F, c & 0x7F),
+ dst);
+ ch = 0;
+ }
+ else
+ ch = c;
+#else
lb = XCHARSET_LEADING_BYTE (charset);
-#endif
switch (XCHARSET_REP_BYTES (charset))
{
case 1: /* ASCII */
case 2: /* one-byte official */
DECODE_OUTPUT_PARTIAL_CHAR (ch);
-#ifdef UTF2000
- DECODE_ADD_UCS_CHAR(MAKE_CHAR(charset, c & 0x7F, 0), dst);
-#else
Dynarr_add (dst, lb);
Dynarr_add (dst, c | 0x80);
-#endif
break;
case 3: /* one-byte private or two-byte official */
-#ifdef UTF2000
- if (XCHARSET_DIMENSION (charset) == 1)
-#else
if (XCHARSET_PRIVATE_P (charset))
-#endif
{
DECODE_OUTPUT_PARTIAL_CHAR (ch);
-#ifdef UTF2000
- DECODE_ADD_UCS_CHAR(MAKE_CHAR(charset, c & 0x7F, 0),
- dst);
-#else
Dynarr_add (dst, PRE_LEADING_BYTE_PRIVATE_1);
Dynarr_add (dst, lb);
Dynarr_add (dst, c | 0x80);
-#endif
}
else
{
if (ch)
{
-#ifdef UTF2000
- DECODE_ADD_UCS_CHAR(MAKE_CHAR(charset,
- ch & 0x7F,
- c & 0x7F), dst);
-#else
Dynarr_add (dst, lb);
Dynarr_add (dst, ch | 0x80);
Dynarr_add (dst, c | 0x80);
-#endif
ch = 0;
}
else
default: /* two-byte private */
if (ch)
{
-#ifdef UTF2000
- DECODE_ADD_UCS_CHAR(MAKE_CHAR(charset,
- ch & 0x7F,
- c & 0x7F), dst);
-#else
Dynarr_add (dst, PRE_LEADING_BYTE_PRIVATE_2);
Dynarr_add (dst, lb);
Dynarr_add (dst, ch | 0x80);
Dynarr_add (dst, c | 0x80);
-#endif
ch = 0;
}
else
ch = c;
}
+#endif
}
if (!ch)
}
if (flags & CODING_STATE_END)
- DECODE_OUTPUT_PARTIAL_CHAR (ch);
-
+ {
+ COMPOSE_FLUSH_CHARS (str, dst);
+ DECODE_OUTPUT_PARTIAL_CHAR (ch);
+ }
str->flags = flags;
str->ch = ch;
}
{
static CONST char inter94[] = "()*+";
static CONST char inter96[] = ",-./";
- unsigned int type;
+ unsigned short chars;
+ unsigned char dimension;
unsigned char final;
Lisp_Object old_charset = str->iso2022.charset[reg];
if (!CHARSETP (charset))
/* charset might be an initial nil or t. */
return;
- type = XCHARSET_TYPE (charset);
+ chars = XCHARSET_CHARS (charset);
+ dimension = XCHARSET_DIMENSION (charset);
final = XCHARSET_FINAL (charset);
if (!str->iso2022.force_charset_on_output[reg] &&
CHARSETP (old_charset) &&
- XCHARSET_TYPE (old_charset) == type &&
+ XCHARSET_CHARS (old_charset) == chars &&
+ XCHARSET_DIMENSION (old_charset) == dimension &&
XCHARSET_FINAL (old_charset) == final)
return;
}
Dynarr_add (dst, ISO_CODE_ESC);
- switch (type)
+ switch (chars)
{
- case CHARSET_TYPE_94:
- Dynarr_add (dst, inter94[reg]);
- break;
- case CHARSET_TYPE_96:
- Dynarr_add (dst, inter96[reg]);
- break;
- case CHARSET_TYPE_94X94:
- Dynarr_add (dst, '$');
- if (reg != 0
- || !(CODING_SYSTEM_ISO2022_SHORT (str->codesys))
- || final < '@'
- || final > 'B')
+ case 94:
+ if (dimension == 1)
Dynarr_add (dst, inter94[reg]);
+ else
+ {
+ Dynarr_add (dst, '$');
+ if (reg != 0
+ || !(CODING_SYSTEM_ISO2022_SHORT (str->codesys))
+ || final < '@'
+ || final > 'B')
+ Dynarr_add (dst, inter94[reg]);
+ }
break;
- case CHARSET_TYPE_96X96:
- Dynarr_add (dst, '$');
- Dynarr_add (dst, inter96[reg]);
+ case 96:
+ if (dimension == 1)
+ Dynarr_add (dst, inter96[reg]);
+ else
+ {
+ Dynarr_add (dst, '$');
+ Dynarr_add (dst, inter96[reg]);
+ }
break;
}
Dynarr_add (dst, final);
Lisp_Coding_System* codesys = str->codesys;
eol_type_t eol_type = CODING_SYSTEM_EOL_TYPE (str->codesys);
int i;
- Lisp_Object charset;
- int half;
+ Lisp_Object charset = str->iso2022.current_charset;
+ int half = str->iso2022.current_half;
unsigned int byte1, byte2;
if (ch <= 0x7F)
{
int reg;
- BREAKUP_CHAR (ch, charset, byte1, byte2);
- ensure_correct_direction (XCHARSET_DIRECTION (charset),
- codesys, dst, flags, 0);
-
/* Now determine which register to use. */
reg = -1;
for (i = 0; i < 4; i++)
{
- if (EQ (charset, str->iso2022.charset[i]) ||
- EQ (charset,
- CODING_SYSTEM_ISO2022_INITIAL_CHARSET (codesys, i)))
+ int code_point;
+
+ if ((CHARSETP (charset = str->iso2022.charset[i])
+ && ((code_point = charset_code_point (charset, ch)) >= 0))
+ ||
+ (CHARSETP
+ (charset
+ = CODING_SYSTEM_ISO2022_INITIAL_CHARSET (codesys, i))
+ && ((code_point = charset_code_point (charset, ch)) >= 0)))
{
+ if (XCHARSET_DIMENSION (charset) == 1)
+ {
+ byte1 = code_point;
+ byte2 = 0;
+ }
+ else /* if (XCHARSET_DIMENSION (charset) == 2) */
+ {
+ byte1 = code_point >> 8;
+ byte2 = code_point & 255;
+ }
reg = i;
break;
}
}
-
+ if (reg == -1)
+ {
+ Lisp_Object original_default_coded_charset_priority_list
+ = Vdefault_coded_charset_priority_list;
+
+ while (!EQ (Vdefault_coded_charset_priority_list, Qnil))
+ {
+ BREAKUP_CHAR (ch, charset, byte1, byte2);
+ if (XCHARSET_FINAL (charset))
+ goto found;
+ Vdefault_coded_charset_priority_list
+ = Fcdr (Fmemq (XCHARSET_NAME (charset),
+ Vdefault_coded_charset_priority_list));
+ }
+ BREAKUP_CHAR (ch, charset, byte1, byte2);
+ if (!XCHARSET_FINAL (charset))
+ {
+ charset = Vcharset_ascii;
+ byte1 = '~';
+ }
+ found:
+ Vdefault_coded_charset_priority_list
+ = original_default_coded_charset_priority_list;
+ }
+ ensure_correct_direction (XCHARSET_DIRECTION (charset),
+ codesys, dst, flags, 0);
+
if (reg == -1)
{
if (XCHARSET_GRAPHIC (charset) != 0)
abort ();
}
}
+ str->iso2022.current_charset = charset;
+ str->iso2022.current_half = half;
}
void
{
c = *src++;
#ifdef UTF2000
- switch (char_boundary)
+ if (char_boundary == 0)
+ if ( c >= 0xfc )
+ {
+ ch = c & 0x01;
+ char_boundary = 5;
+ }
+ else if ( c >= 0xf8 )
+ {
+ ch = c & 0x03;
+ char_boundary = 4;
+ }
+ else if ( c >= 0xf0 )
+ {
+ ch = c & 0x07;
+ char_boundary = 3;
+ }
+ else if ( c >= 0xe0 )
+ {
+ ch = c & 0x0f;
+ char_boundary = 2;
+ }
+ else if ( c >= 0xc0 )
+ {
+ ch = c & 0x1f;
+ char_boundary = 1;
+ }
+ else
+ {
+ ch = 0;
+ if (c == '\n')
+ {
+ if (eol_type != EOL_LF && eol_type != EOL_AUTODETECT)
+ Dynarr_add (dst, '\r');
+ if (eol_type != EOL_CR)
+ Dynarr_add (dst, c);
+ }
+ else
+ Dynarr_add (dst, c);
+ char_boundary = 0;
+ }
+ else if (char_boundary == 1)
{
- case 0:
- if ( c >= 0xfc )
- {
- ch = c & 0x01;
- char_boundary = 5;
- }
- else if ( c >= 0xf8 )
- {
- ch = c & 0x03;
- char_boundary = 4;
- }
- else if ( c >= 0xf0 )
- {
- ch = c & 0x07;
- char_boundary = 3;
- }
- else if ( c >= 0xe0 )
- {
- ch = c & 0x0f;
- char_boundary = 2;
- }
- else if ( c >= 0xc0 )
- {
- ch = c & 0x1f;
- char_boundary = 1;
- }
- else
- {
- ch = 0;
-
- if (c == '\n')
- {
- if (eol_type != EOL_LF && eol_type != EOL_AUTODETECT)
- Dynarr_add (dst, '\r');
- if (eol_type != EOL_CR)
- Dynarr_add (dst, c);
- }
- else
- Dynarr_add (dst, c);
- char_boundary = 0;
- }
- break;
- case 1:
ch = ( ch << 6 ) | ( c & 0x3f );
- switch ( str->codesys->fixed.size )
- {
- case 1:
- Dynarr_add (dst, ch & 0xff);
- break;
- case 2:
- Dynarr_add (dst, (ch >> 8) & 0xff);
- Dynarr_add (dst, ch & 0xff);
- break;
- case 3:
- Dynarr_add (dst, (ch >> 16) & 0xff);
- Dynarr_add (dst, (ch >> 8) & 0xff);
- Dynarr_add (dst, ch & 0xff);
- break;
- case 4:
- Dynarr_add (dst, (ch >> 24) & 0xff);
- Dynarr_add (dst, (ch >> 16) & 0xff);
- Dynarr_add (dst, (ch >> 8) & 0xff);
- Dynarr_add (dst, ch & 0xff);
- break;
- default:
- fprintf(stderr, "It seems %d bytes stream.\n",
- str->codesys->fixed.size);
- abort ();
- }
+ Dynarr_add (dst, ch & 0xff);
char_boundary = 0;
- break;
- default:
+ }
+ else
+ {
ch = ( ch << 6 ) | ( c & 0x3f );
char_boundary--;
}
GCPRO3 (instream, outstream, da_outstream);
while (1)
{
- int size_in_bytes = Lstream_read (istr, tempbuf, sizeof (tempbuf));
+ ssize_t size_in_bytes = Lstream_read (istr, tempbuf, sizeof (tempbuf));
if (!size_in_bytes)
break;
Lstream_write (ostr, tempbuf, size_in_bytes);
void
syms_of_file_coding (void)
{
- defsymbol (&Qbuffer_file_coding_system, "buffer-file-coding-system");
deferror (&Qcoding_system_error, "coding-system-error",
"Coding-system error", Qio_error);
DEFSUBR (Fencode_shift_jis_char);
DEFSUBR (Fdecode_big5_char);
DEFSUBR (Fencode_big5_char);
- DEFSUBR (Fset_ucs_char);
- DEFSUBR (Fucs_char);
- DEFSUBR (Fset_char_ucs);
- DEFSUBR (Fchar_ucs);
#endif /* MULE */
- defsymbol (&Qcoding_system_p, "coding-system-p");
+ defsymbol (&Qcoding_systemp, "coding-system-p");
defsymbol (&Qno_conversion, "no-conversion");
defsymbol (&Qraw_text, "raw-text");
#ifdef MULE
defsymbol (&Qlock_shift, "lock-shift");
defsymbol (&Qescape_quoted, "escape-quoted");
#endif /* MULE */
+#ifdef UTF2000
+ defsymbol (&Qdisable_composition, "disable-composition");
+#endif
defsymbol (&Qencode, "encode");
defsymbol (&Qdecode, "decode");
{
int i;
+ fcd = xnew (struct file_coding_dump);
+ dumpstruct (&fcd, &fcd_description);
+
/* Initialize to something reasonable ... */
for (i = 0; i <= CODING_CATEGORY_LAST; i++)
{
- coding_category_system[i] = Qnil;
- coding_category_by_priority[i] = i;
+ fcd->coding_category_system[i] = Qnil;
+ fcd->coding_category_by_priority[i] = i;
}
Fprovide (intern ("file-coding"));
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);
#define DEFINE_CODESYS_PROP(Prop_Type, Sym) do \
{ \
Fdefine_coding_system_alias (Qno_conversion, Qraw_text);
/* Need this for bootstrapping */
- coding_category_system[CODING_CATEGORY_NO_CONVERSION] =
+ fcd->coding_category_system[CODING_CATEGORY_NO_CONVERSION] =
Fget_coding_system (Qraw_text);
#ifdef UTF2000
- coding_category_system[CODING_CATEGORY_UTF8]
+ fcd->coding_category_system[CODING_CATEGORY_UTF8]
= Fget_coding_system (Qutf8);
#endif
-
-#ifdef MULE
- {
- unsigned int i;
-
- for (i = 0; i < 65536; i++)
- ucs_to_mule_table[i] = Qnil;
- }
- staticpro (&mule_to_ucs_table);
- mule_to_ucs_table = Fmake_char_table(Qgeneric);
-#endif /* MULE */
}