xemacs-beta: src/mule-coding.c comparison

comparison src/mule-coding.c @ 272:c5d627a313b1 r21-0b34

Import from CVS: tag r21-0b34

author	cvs
date	Mon, 13 Aug 2007 10:28:48 +0200
parents	11cf20601dec
children	70ad99077275

comparison

equal deleted inserted replaced

-:c7b7086b0a39
+:c5d627a313b1
 literally because we didn't know about the invalid designation;
 but we have to do so now. */
 unsigned int output_direction_sequence :1;
 };
-Lisp_Object Fcopy_coding_system (Lisp_Object old_coding_system,
+EXFUN (Fcopy_coding_system, 2);
-				 Lisp_Object new_name);
 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,
 /************************************************************************/
 /*                       Coding system functions                        */
 /************************************************************************/
-static Lisp_Object mark_coding_system (Lisp_Object, void (*) (Lisp_Object));
-static void print_coding_system (Lisp_Object, Lisp_Object, int);
-static void finalize_coding_system (void *header, int for_disksave);
-DEFINE_LRECORD_IMPLEMENTATION ("coding-system", coding_system,
-			       mark_coding_system, print_coding_system,
-			       finalize_coding_system,
-			       0, 0, struct Lisp_Coding_System);
 static Lisp_Object
 mark_coding_system (Lisp_Object obj, void (*markobj) (Lisp_Object))
 {
 struct Lisp_Coding_System *codesys = XCODING_SYSTEM (obj);
 	  break;
 	}
 }
 }
+DEFINE_LRECORD_IMPLEMENTATION ("coding-system", coding_system,
+			       mark_coding_system, print_coding_system,
+			       finalize_coding_system,
+			       0, 0, struct Lisp_Coding_System);
 static enum eol_type
 symbol_to_eol_type (Lisp_Object symbol)
 {
 CHECK_SYMBOL (symbol);
 if (NILP (symbol))      return EOL_AUTODETECT;
 }
 static void
 setup_eol_coding_systems (struct Lisp_Coding_System *codesys)
 {
-Lisp_Object codesys_obj = Qnil;
+Lisp_Object codesys_obj;
 int len = string_length (XSYMBOL (CODING_SYSTEM_NAME (codesys))->name);
 char *codesys_name = (char *) alloca (len + 7);
 Lisp_Object codesys_name_sym, sub_codesys_obj;
 /* kludge */
 DEFINE_SUB_CODESYS("dos",  EOL_CRLF);
 DEFINE_SUB_CODESYS("mac",  EOL_CR);
 }
 DEFUN ("coding-system-p", Fcoding_system_p, 1, 1, 0, /*
-T if OBJECT is a coding system.
+Return t if OBJECT is a coding system.
 A coding system is an object that defines how text containing multiple
 character sets is encoded into a stream of (typically 8-bit) bytes.
 The coding system is used to decode the stream into a series of
 characters (which may be from multiple charsets) when the text is read
 from a file or process, and is used to encode the text back into the
 static
 Lisp_Object coding_system_charset (Lisp_Object coding_system, int gnum)
 {
 Lisp_Object cs
 = XCODING_SYSTEM_ISO2022_INITIAL_CHARSET (coding_system, gnum);
-if (CHARSETP(cs)){
+return CHARSETP (cs) ? XCHARSET_NAME (cs) : Qnil;
-return XCHARSET_NAME(cs);
-}
-else {
-return Qnil;
-}
 }
 DEFUN ("coding-system-charset", Fcoding_system_charset, 2, 2, 0, /*
 Return initial charset of CODING-SYSTEM designated to GNUM.
 GNUM allows 0 .. 3.
 (coding_system, gnum))
 {
 coding_system = Fget_coding_system (coding_system);
 CHECK_INT (gnum);
-return coding_system_charset(coding_system, XINT (gnum));
+return coding_system_charset (coding_system, XINT (gnum));
 }
 DEFUN ("coding-system-property", Fcoding_system_property, 2, 2, 0, /*
 Return the PROP property of CODING-SYSTEM.
 */
 enum eol_type eol_type;
 int seen_non_ascii;
 int mask;
 struct
 {
 int mask;
 int in_second_byte;
 }
 big5;
 struct
 {
 int mask;
 int in_second_byte;
 }
 shift_jis;
 struct
 {
 int mask;
 int initted;
 struct iso2022_decoder iso;
 unsigned int flags;
 int high_byte_count;
 unsigned int saw_single_shift:1;
 }
 iso2022;
 struct
 {
 int seen_anything;
 int just_saw_cr;
 }
 eol;
 };
 static int
 acceptable_control_char_p (int c)
 struct detection_state decst;
 if (*eol_type_in_out == EOL_AUTODETECT)
 *eol_type_in_out = XCODING_SYSTEM_EOL_TYPE (*codesys_in_out);
-memset (&decst, 0, sizeof (decst));
+xzero (decst);
 decst.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 ||
 lb_instream = make_lisp_buffer_input_stream (buf, b, e, 0);
 lb_istr = XLSTREAM (lb_instream);
 instream = make_encoding_input_stream (lb_istr, Fget_coding_system (Qbinary));
 istr = XLSTREAM (instream);
 GCPRO2 (instream, lb_instream);
-memset (&decst, 0, sizeof (decst));
+xzero (decst);
 decst.eol_type = EOL_AUTODETECT;
 decst.mask = ~0;
 while (1)
 {
 unsigned char random_buffer[4096];
 struct ccl_program ccl;
 struct detection_state decst;
 };
-static int decoding_reader     (Lstream *stream,       unsigned char *data, int size);
+static int decoding_reader     (Lstream *stream,       unsigned char *data, size_t size);
-static int decoding_writer     (Lstream *stream, CONST unsigned char *data, int size);
+static int 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,
 /* 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
-decoding_reader (Lstream *stream, unsigned char *data, int size)
+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;
 int error_occurred = 0;
 {
 /* Take data from the runoff if we can.  Make sure to take at
 	 most SIZE bytes, and delete the data from the runoff. */
 if (Dynarr_length (str->runoff) > 0)
 	{
-	  int chunk = min (size, Dynarr_length (str->runoff));
+	  size_t chunk = min (size, (size_t) Dynarr_length (str->runoff));
 	  memcpy (data, Dynarr_atp (str->runoff, 0), chunk);
 	  Dynarr_delete_many (str->runoff, 0, chunk);
 	  data += chunk;
 	  size -= chunk;
 	}
 else
 return data - orig_data;
 }
 static int
-decoding_writer (Lstream *stream, CONST unsigned char *data, int size)
+decoding_writer (Lstream *stream, CONST unsigned char *data, size_t size)
 {
 struct decoding_stream *str = DECODING_STREAM_DATA (stream);
 int retval;
 /* Decode all our data into the runoff, and then attempt to write
 static void
 reset_decoding_stream (struct decoding_stream *str)
 {
 if (CODING_SYSTEM_TYPE (str->codesys) == CODESYS_ISO2022)
 {
-Lisp_Object coding_system = Qnil;
+Lisp_Object coding_system;
 XSETCODING_SYSTEM (coding_system, str->codesys);
 reset_iso2022 (coding_system, &str->iso2022);
 }
 else if (CODING_SYSTEM_TYPE (str->codesys) == CODESYS_CCL)
 {
 }
 Lisp_Object
 decoding_stream_coding_system (Lstream *stream)
 {
-Lisp_Object coding_system = Qnil;
+Lisp_Object coding_system;
 struct decoding_stream *str = DECODING_STREAM_DATA (stream);
 XSETCODING_SYSTEM (coding_system, str->codesys);
 return subsidiary_coding_system (coding_system, str->eol_type);
 }
 {
 Lstream *lstr = Lstream_new (lstream_decoding, mode);
 struct decoding_stream *str = DECODING_STREAM_DATA (lstr);
 Lisp_Object obj;
-memset (str, 0, sizeof (*str));
+xzero (*str);
 str->other_end = stream;
 str->runoff = (unsigned_char_dynarr *) Dynarr_new (unsigned_char);
 str->eol_type = EOL_AUTODETECT;
 if (!strcmp (mode, "r")
 && Lstream_seekable_p (stream))
 rewind, and start over. */
 if (CODING_SYSTEM_TYPE (str->codesys) == CODESYS_AUTODETECT ||
 str->eol_type == EOL_AUTODETECT)
 {
-Lisp_Object codesys = Qnil;
+Lisp_Object codesys;
 XSETCODING_SYSTEM (codesys, str->codesys);
 detect_coding_type (&str->decst, src, n,
 			  CODING_SYSTEM_TYPE (str->codesys) !=
 			  CODESYS_AUTODETECT);
 /* Additional information (the state of the running CCL program)
 used by the CCL encoder. */
 struct ccl_program ccl;
 };
-static int encoding_reader (Lstream *stream, unsigned char *data, int size);
+static int encoding_reader (Lstream *stream, unsigned char *data, size_t size);
 static int encoding_writer (Lstream *stream, CONST unsigned char *data,
-			    int size);
+			    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,
 /* 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
-encoding_reader (Lstream *stream, unsigned char *data, int size)
+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;
 int error_occurred = 0;
 {
 /* Take data from the runoff if we can.  Make sure to take at
 	 most SIZE bytes, and delete the data from the runoff. */
 if (Dynarr_length (str->runoff) > 0)
 	{
-	  int chunk = min (size, Dynarr_length (str->runoff));
+	  int chunk = min ((int) size, Dynarr_length (str->runoff));
 	  memcpy (data, Dynarr_atp (str->runoff, 0), chunk);
 	  Dynarr_delete_many (str->runoff, 0, chunk);
 	  data += chunk;
 	  size -= chunk;
 	}
 else
 return data - orig_data;
 }
 static int
-encoding_writer (Lstream *stream, CONST unsigned char *data, int size)
+encoding_writer (Lstream *stream, CONST unsigned char *data, size_t size)
 {
 struct encoding_stream *str = ENCODING_STREAM_DATA (stream);
 int retval;
 /* Encode all our data into the runoff, and then attempt to write
 }
 Lisp_Object
 encoding_stream_coding_system (Lstream *stream)
 {
-Lisp_Object coding_system = Qnil;
+Lisp_Object coding_system;
 struct encoding_stream *str = ENCODING_STREAM_DATA (stream);
 XSETCODING_SYSTEM (coding_system, str->codesys);
 return coding_system;
 }
 {
 Lstream *lstr = Lstream_new (lstream_encoding, mode);
 struct encoding_stream *str = ENCODING_STREAM_DATA (lstr);
 Lisp_Object obj;
-memset (str, 0, sizeof (*str));
+xzero (*str);
 str->runoff = Dynarr_new (unsigned_char);
 str->other_end = stream;
 set_encoding_stream_coding_system (lstr, codesys);
 XSETLSTREAM (obj, lstr);
 return obj;
 {
 unsigned char c;
 unsigned int flags, ch;
 enum eol_type eol_type;
 struct decoding_stream *str = DECODING_STREAM_DATA (decoding);
-Lisp_Object coding_system = Qnil;
+Lisp_Object coding_system;
 unsigned_char_dynarr *real_dst = dst;
 CODING_STREAM_DECOMPOSE (str, flags, ch);
 eol_type = str->eol_type;
 XSETCODING_SYSTEM (coding_system, str->codesys);
 static void
 iso2022_designate (Lisp_Object charset, unsigned char reg,
 		   struct encoding_stream *str, unsigned_char_dynarr *dst)
 {
 CONST char *inter94 = "()*+", *inter96= ",-./";
-int type;
+unsigned int type;
 unsigned char final;
 Lisp_Object old_charset = str->iso2022.charset[reg];
 str->iso2022.charset[reg] = charset;
 if (!CHARSETP (charset))
 (((fmt) == FORMAT_FILENAME) ? FILE_NAME_CODING_SYSTEM     :	\
 ((fmt) == FORMAT_CTEXT   ) ? Fget_coding_system (Qctext) :	\
 ((fmt) == FORMAT_TERMINAL) ? FILE_NAME_CODING_SYSTEM     :	\
 Qnil)
-extern CONST Extbyte *
+CONST Extbyte *
 convert_to_external_format (CONST Bufbyte *ptr,
 			    Bytecount len,
 			    Extcount *len_out,
 			    enum external_data_format fmt)
 {
 *len_out = Dynarr_length (conversion_out_dynarr);
 Dynarr_add (conversion_out_dynarr, 0); /* remember to zero-terminate! */
 return Dynarr_atp (conversion_out_dynarr, 0);
 }
-extern CONST Bufbyte *
+CONST Bufbyte *
 convert_from_external_format (CONST Extbyte *ptr,
 			      Extcount len,
 			      Bytecount *len_out,
 			      enum external_data_format fmt)
 {

Mercurial > hg > xemacs-beta

comparison src/mule-coding.c @ 272:c5d627a313b1 r21-0b34