emacs: src/coding.c comparison

comparison src/coding.c @ 30833:2db6e42a6ba3

(MINIMUM_CONVERSION_BUFFER_SIZE): Macro deleted. (conversion_buffer, conversion_buffer_size): Variables deleted. (get_conversion_buffer): Function deleted. (struct conversion_buffer): New structure. (MAX_ALLOCA): New macro. (allocate_conversion_buffer): New macro. (extend_conversion_buffer, free_conversion_buffer): New functions. (ccl_coding_driver): Set coding->result. (decode_coding): Set coding->result to CODING_FINISH_NORMAL if this is the last block of source. (encode_coding): Likewise. Handle the source block as the last one only when the whole source text is consumed. (decode_coding_string): Handle the case that the output buffer is too small to decode the whole source text. Use allocate_conversion_buffer, extend_conversion_buffer and free_conversion_buffer, not get_conversion_buffer. (encode_coding_string): Likewise. (init_coding): Function deleted. (init_coding_once): Delete code to initialize conversion_buffer_size.

author	Kenichi Handa <handa@m17n.org>
date	Wed, 16 Aug 2000 01:37:20 +0000
parents	b72c2759ac70
children	91e24edb537a

comparison

equal deleted inserted replaced

-:b0b1acff966b
+:2db6e42a6ba3
 magnification = 1;
 return (src_bytes * magnification + CONVERSION_BUFFER_EXTRA_ROOM);
 }
-#ifndef MINIMUM_CONVERSION_BUFFER_SIZE
+/* Working buffer for code conversion.  */
-#define MINIMUM_CONVERSION_BUFFER_SIZE 1024
+struct conversion_buffer
-#endif
+{
+int size;			/* size of data.  */
-char *conversion_buffer;
+int on_stack;			/* 1 if allocated by alloca.  */
-int conversion_buffer_size;
+unsigned char *data;
+};
-/* Return a pointer to a SIZE bytes of buffer to be used for encoding
-or decoding.  Sufficient memory is allocated automatically.  If we
+/* Don't use alloca for allocating memory space larger than this, lest
-run out of memory, return NULL.  */
+we overflow their stack.  */
+#define MAX_ALLOCA 16*1024
-char *
-get_conversion_buffer (size)
+/* Allocate LEN bytes of memory for BUF (struct conversion_buffer).  */
-int size;
+#define allocate_conversion_buffer(buf, len)		\
-{
+do {							\
-if (size > conversion_buffer_size)
+if (len < MAX_ALLOCA)				\
-{
+{							\
-char *buf;
+	buf.data = (unsigned char *) alloca (len);	\
-int real_size = conversion_buffer_size * 2;
+	buf.on_stack = 1;				\
+}							\
-while (real_size < size) real_size *= 2;
+else						\
-buf = (char *) xmalloc (real_size);
+{							\
-xfree (conversion_buffer);
+	buf.data = (unsigned char *) xmalloc (len);	\
-conversion_buffer = buf;
+	buf.on_stack = 0;				\
-conversion_buffer_size = real_size;
+}							\
-}
+buf.size = len;					\
-return conversion_buffer;
+} while (0)
+/* Double the allocated memory for *BUF.  */
+static void
+extend_conversion_buffer (buf)
+struct conversion_buffer *buf;
+{
+if (buf->on_stack)
+{
+unsigned char *save = buf->data;
+buf->data = (unsigned char *) xmalloc (buf->size * 2);
+bcopy (save, buf->data, buf->size);
+buf->on_stack = 0;
+}
+else
+{
+buf->data = (unsigned char *) xrealloc (buf->data, buf->size * 2);
+}
+buf->size *= 2;
+}
+/* Free the allocated memory for BUF if it is not on stack.  */
+static void
+free_conversion_buffer (buf)
+struct conversion_buffer *buf;
+{
+if (!buf->on_stack)
+xfree (buf->data);
 }
 int
 ccl_coding_driver (coding, source, destination, src_bytes, dst_bytes, encodep)
 struct coding_system *coding;
 }
 switch (ccl->status)
 {
 case CCL_STAT_SUSPEND_BY_SRC:
-result = CODING_FINISH_INSUFFICIENT_SRC;
+coding->result = CODING_FINISH_INSUFFICIENT_SRC;
 break;
 case CCL_STAT_SUSPEND_BY_DST:
-result = CODING_FINISH_INSUFFICIENT_DST;
+coding->result = CODING_FINISH_INSUFFICIENT_DST;
 break;
 case CCL_STAT_QUIT:
 case CCL_STAT_INVALID_CMD:
-result = CODING_FINISH_INTERRUPT;
+coding->result = CODING_FINISH_INTERRUPT;
 break;
 default:
-result = CODING_FINISH_NORMAL;
+coding->result = CODING_FINISH_NORMAL;
 break;
 }
-return result;
+return coding->result;
 }
 /* Decode EOL format of the text at PTR of BYTES length destructively
 according to CODING->eol_type.  This is called after the CCL
 program produced a decoded text at PTR.  If we do CRLF->LF
 	  dst += CHAR_STRING (c, dst);
 	  coding->produced_char++;
 	}
 coding->consumed = coding->consumed_char = src - source;
 coding->produced = dst - destination;
+coding->result = CODING_FINISH_NORMAL;
 }
 if (!coding->dst_multibyte)
 {
 coding->produced = str_as_unibyte (destination, coding->produced);
 if (coding->result == CODING_FINISH_INSUFFICIENT_SRC
 && coding->consumed == src_bytes)
 coding->result = CODING_FINISH_NORMAL;
-if (coding->mode & CODING_MODE_LAST_BLOCK)
+if (coding->mode & CODING_MODE_LAST_BLOCK
+&& coding->result == CODING_FINISH_INSUFFICIENT_SRC)
 {
 unsigned char *src = source + coding->consumed;
 unsigned char *src_end = src + src_bytes;
 unsigned char *dst = destination + coding->produced;
 	    len = str_as_unibyte (dst, len);
 	  dst += len;
 	  coding->consumed = src_bytes;
 	}
 coding->produced = coding->produced_char = dst - destination;
+coding->result = CODING_FINISH_NORMAL;
 }
 return coding->result;
 }
 Lisp_Object str;
 struct coding_system *coding;
 int nocopy;
 {
 int len;
-char *buf;
+struct conversion_buffer buf;
 int from, to, to_byte;
 struct gcpro gcpro1;
 Lisp_Object saved_coding_symbol;
 int result;
 int require_decoding;
+int shrinked_bytes = 0;
+Lisp_Object newstr;
+int consumed, produced, produced_char;
 from = 0;
 to = XSTRING (str)->size;
 to_byte = STRING_BYTES (XSTRING (str));
 			   && coding->type != coding_type_raw_text);
 /* Try to skip the heading and tailing ASCIIs.  */
 if (require_decoding && coding->type != coding_type_ccl)
 {
-int from_orig = from;
 SHRINK_CONVERSION_REGION (&from, &to_byte, coding, XSTRING (str)->data,
 				0);
 if (from == to_byte)
 	require_decoding = 0;
+shrinked_bytes = from + (STRING_BYTES (XSTRING (str)) - to_byte);
 }
 if (!require_decoding)
 {
 coding->consumed = STRING_BYTES (XSTRING (str));
 return (nocopy ? str : Fcopy_sequence (str));
 }
 if (coding->composing != COMPOSITION_DISABLED)
 coding_allocate_composition_data (coding, from);
 len = decoding_buffer_size (coding, to_byte - from);
-len += from + STRING_BYTES (XSTRING (str)) - to_byte;
+allocate_conversion_buffer (buf, len);
-GCPRO1 (str);
-buf = get_conversion_buffer (len);
+consumed = produced = produced_char = 0;
-UNGCPRO;
+while (1)
+{
+result = decode_coding (coding, XSTRING (str)->data + from + consumed,
+			      buf.data + produced, to_byte - from - consumed,
+			      buf.size - produced);
+consumed += coding->consumed;
+produced += coding->produced;
+produced_char += coding->produced_char;
+if (result == CODING_FINISH_NORMAL)
+	break;
+if (result == CODING_FINISH_INSUFFICIENT_CMP)
+	coding_allocate_composition_data (coding, from + produced_char);
+else if (result == CODING_FINISH_INSUFFICIENT_DST)
+	extend_conversion_buffer (&buf);
+else if (result == CODING_FINISH_INCONSISTENT_EOL)
+	{
+	  /* Recover the original EOL format.  */
+	  if (coding->eol_type == CODING_EOL_CR)
+	    {
+	      unsigned char *p;
+	      for (p = buf.data; p < buf.data + produced; p++)
+		if (*p == '\n') *p = '\r';
+	    }
+	  else if (coding->eol_type == CODING_EOL_CRLF)
+	    {
+	      int num_eol = 0;
+	      unsigned char *p0, *p1;
+	      for (p0 = buf.data, p1 = p0 + produced; p0 < p1; p0++)
+		if (*p0 == '\n') num_eol++;
+	      if (produced + num_eol >= buf.size)
+		extend_conversion_buffer (&buf);
+	      for (p0 = buf.data + produced, p1 = p0 + num_eol; p0 > buf.data;)
+		{
+		  *--p1 = *--p0;
+		  if (*p0 == '\n') *--p1 = '\r';
+		}
+	      produced += num_eol;
+	      produced_char += num_eol;
+	    }
+	  coding->eol_type = CODING_EOL_LF;
+	  coding->symbol = saved_coding_symbol;
+	}
+}
+if (coding->dst_multibyte)
+newstr = make_uninit_multibyte_string (produced_char + shrinked_bytes,
+					   produced + shrinked_bytes);
+else
+newstr = make_uninit_string (produced + shrinked_bytes);
 if (from > 0)
-bcopy (XSTRING (str)->data, buf, from);
+bcopy (XSTRING (str)->data, XSTRING (newstr)->data, from);
-result = decode_coding (coding, XSTRING (str)->data + from,
+bcopy (buf.data, XSTRING (newstr)->data + from, produced);
-			 buf + from, to_byte - from, len);
+if (shrinked_bytes > from)
-if (result == CODING_FINISH_INCONSISTENT_EOL)
+bcopy (XSTRING (str)->data + to_byte,
-{
+	   XSTRING (newstr)->data + from + produced,
-/* We simply try to decode the whole string again but without
+	   shrinked_bytes - from);
-eol-conversion this time.  */
+free_conversion_buffer (&buf);
-coding->eol_type = CODING_EOL_LF;
-coding->symbol = saved_coding_symbol;
-coding_free_composition_data (coding);
-return decode_coding_string (str, coding, nocopy);
-}
-bcopy (XSTRING (str)->data + to_byte, buf + from + coding->produced,
-	 STRING_BYTES (XSTRING (str)) - to_byte);
-len = from + STRING_BYTES (XSTRING (str)) - to_byte;
-if (coding->dst_multibyte)
-str = make_multibyte_string (buf, len + coding->produced_char,
-				 len + coding->produced);
-else
-str = make_unibyte_string (buf, len + coding->produced);
 if (coding->cmp_data && coding->cmp_data->used)
-coding_restore_composition (coding, str);
+coding_restore_composition (coding, newstr);
 coding_free_composition_data (coding);
 if (SYMBOLP (coding->post_read_conversion)
 && !NILP (Ffboundp (coding->post_read_conversion)))
-str = run_pre_post_conversion_on_str (str, coding, 0);
+newstr = run_pre_post_conversion_on_str (newstr, coding, 0);
-return str;
+return newstr;
 }
 Lisp_Object
 encode_coding_string (str, coding, nocopy)
 Lisp_Object str;
 struct coding_system *coding;
 int nocopy;
 {
 int len;
-char *buf;
+struct conversion_buffer buf;
 int from, to, to_byte;
 struct gcpro gcpro1;
 Lisp_Object saved_coding_symbol;
 int result;
+int shrinked_bytes = 0;
+Lisp_Object newstr;
+int consumed, consumed_char, produced;
 if (SYMBOLP (coding->pre_write_conversion)
 && !NILP (Ffboundp (coding->pre_write_conversion)))
 str = run_pre_post_conversion_on_str (str, coding, 1);
 coding_save_composition (coding, from, to, str);
 /* Try to skip the heading and tailing ASCIIs.  */
 if (coding->type != coding_type_ccl)
 {
-int from_orig = from;
 SHRINK_CONVERSION_REGION (&from, &to_byte, coding, XSTRING (str)->data,
 				1);
 if (from == to_byte)
 	return (nocopy ? str : Fcopy_sequence (str));
+shrinked_bytes = from + (STRING_BYTES (XSTRING (str)) - to_byte);
 }
 len = encoding_buffer_size (coding, to_byte - from);
-len += from + STRING_BYTES (XSTRING (str)) - to_byte;
+allocate_conversion_buffer (buf, len);
-GCPRO1 (str);
-buf = get_conversion_buffer (len);
+consumed = consumed_char = produced = 0;
-UNGCPRO;
+while (1)
+{
+result = encode_coding (coding, XSTRING (str)->data + from + consumed,
+			      buf.data + produced, to_byte - from - consumed,
+			      buf.size - produced);
+consumed += coding->consumed;
+produced += coding->produced;
+if (result == CODING_FINISH_NORMAL)
+	break;
+/* Now result should be CODING_FINISH_INSUFFICIENT_DST.  */
+extend_conversion_buffer (&buf);
+}
+newstr = make_uninit_string (produced + shrinked_bytes);
 if (from > 0)
-bcopy (XSTRING (str)->data, buf, from);
+bcopy (XSTRING (str)->data, XSTRING (newstr)->data, from);
-result = encode_coding (coding, XSTRING (str)->data + from,
+bcopy (buf.data, XSTRING (newstr)->data + from, produced);
-			  buf + from, to_byte - from, len);
+if (shrinked_bytes > from)
-bcopy (XSTRING (str)->data + to_byte, buf + from + coding->produced,
+bcopy (XSTRING (str)->data + to_byte,
-	 STRING_BYTES (XSTRING (str)) - to_byte);
+	   XSTRING (newstr)->data + from + produced,
+	   shrinked_bytes - from);
-len = from + STRING_BYTES (XSTRING (str)) - to_byte;
-str = make_unibyte_string (buf, len + coding->produced);
+free_conversion_buffer (&buf);
 coding_free_composition_data (coding);
-return str;
+return newstr;
 }
 #ifdef emacs
 /*** 8. Emacs Lisp library functions ***/
 /*** 9. Post-amble ***/
 void
-init_coding ()
-{
-conversion_buffer = (char *) xmalloc (MINIMUM_CONVERSION_BUFFER_SIZE);
-}
-void
 init_coding_once ()
 {
 int i;
 /* Emacs' internal format specific initialize routine.  */
 iso_code_class[ISO_CODE_SS2_7] = ISO_single_shift_2_7;
 iso_code_class[ISO_CODE_ESC] = ISO_escape;
 iso_code_class[ISO_CODE_SS2] = ISO_single_shift_2;
 iso_code_class[ISO_CODE_SS3] = ISO_single_shift_3;
 iso_code_class[ISO_CODE_CSI] = ISO_control_sequence_introducer;
-conversion_buffer_size = MINIMUM_CONVERSION_BUFFER_SIZE;
 setup_coding_system (Qnil, &keyboard_coding);
 setup_coding_system (Qnil, &terminal_coding);
 setup_coding_system (Qnil, &safe_terminal_coding);
 setup_coding_system (Qnil, &default_buffer_file_coding);

Mercurial > emacs

comparison src/coding.c @ 30833:2db6e42a6ba3