xemacs-beta: src/buffer.c comparison

comparison src/buffer.c @ 440:8de8e3f6228a r21-2-28

Import from CVS: tag r21-2-28

author	cvs
date	Mon, 13 Aug 2007 11:33:38 +0200
parents	9d177e8d4150
children	abe6d1db359e

comparison

equal deleted inserted replaced

-:357dd071b03c
+:8de8e3f6228a
 #include "chartab.h"
 #include "commands.h"
 #include "elhash.h"
 #include "extents.h"
 #include "faces.h"
+#ifdef FILE_CODING
+#include "file-coding.h"
+#endif
 #include "frame.h"
 #include "insdel.h"
+#include "lstream.h"
 #include "process.h"            /* for kill_buffer_processes */
 #ifdef REGION_CACHE_NEEDS_WORK
 #include "region-cache.h"
 #endif
 #include "specifier.h"
 XCDR (prev) = XCDR (XCDR (prev));
 XCDR (lynk) = f->buffer_alist;
 f->buffer_alist = lynk;
 va_run_hook_with_args (Qrecord_buffer_hook, 1, buffer);
 return Qnil;
 }
 DEFUN ("set-buffer-major-mode", Fset_buffer_major_mode, 1, 1, 0, /*
 Set an appropriate major mode for BUFFER, according to `default-major-mode'.
 return Fnreverse (val);
 }
 #endif /* MEMORY_USAGE_STATS */
+/************************************************************************/
+/*           Implement TO_EXTERNAL_FORMAT, TO_INTERNAL_FORMAT           */
+/************************************************************************/
+/* This implementation should probably be elsewhere, but it can't be
+in file-coding.c since that file is only available if FILE_CODING
+is defined. */
+#ifdef FILE_CODING
+static int
+coding_system_is_binary (Lisp_Object coding_system)
+{
+Lisp_Coding_System *cs = XCODING_SYSTEM (coding_system);
+return
+(CODING_SYSTEM_TYPE (cs) == CODESYS_NO_CONVERSION &&
+CODING_SYSTEM_EOL_TYPE (cs) == EOL_LF &&
+EQ (CODING_SYSTEM_POST_READ_CONVERSION (cs), Qnil) &&
+EQ (CODING_SYSTEM_PRE_WRITE_CONVERSION (cs), Qnil));
+}
+#else
+#define coding_system_is_binary(coding_system) 1
+#endif
+static Extbyte_dynarr *conversion_out_dynarr;
+static Bufbyte_dynarr *conversion_in_dynarr;
+static int dfc_convert_to_external_format_in_use;
+static int dfc_convert_to_internal_format_in_use;
+static Lisp_Object
+dfc_convert_to_external_format_reset_in_use (Lisp_Object value)
+{
+dfc_convert_to_external_format_in_use = XINT (value);
+return Qnil;
+}
+static Lisp_Object
+dfc_convert_to_internal_format_reset_in_use (Lisp_Object value)
+{
+dfc_convert_to_internal_format_in_use = XINT (value);
+return Qnil;
+}
+void
+dfc_convert_to_external_format (dfc_conversion_type source_type,
+				dfc_conversion_data *source,
+#ifdef FILE_CODING
+				Lisp_Object coding_system,
+#endif
+				dfc_conversion_type sink_type,
+				dfc_conversion_data *sink)
+{
+int count = specpdl_depth ();
+type_checking_assert
+(((source_type == DFC_TYPE_DATA) ||
+(source_type == DFC_TYPE_LISP_LSTREAM && LSTREAMP (source->lisp_object)) ||
+(source_type == DFC_TYPE_LISP_STRING && STRINGP (source->lisp_object)))
+&&
+((sink_type == DFC_TYPE_DATA) ||
+(sink_type == DFC_TYPE_LISP_LSTREAM && LSTREAMP (source->lisp_object))));
+if (dfc_convert_to_external_format_in_use != 0)
+error ("Can't call a conversion function from a conversion function");
+else
+dfc_convert_to_external_format_in_use = 1;
+record_unwind_protect (dfc_convert_to_external_format_reset_in_use,
+			 Qzero);
+#ifdef FILE_CODING
+coding_system = Fget_coding_system (coding_system);
+#endif
+Dynarr_reset (conversion_out_dynarr);
+/* Here we optimize in the case where the coding system does no
+conversion. However, we don't want to optimize in case the source
+or sink is an lstream, since writing to an lstream can cause a
+garbage collection, and this could be problematic if the source
+is a lisp string. */
+if (source_type != DFC_TYPE_LISP_LSTREAM &&
+sink_type   != DFC_TYPE_LISP_LSTREAM &&
+coding_system_is_binary (coding_system))
+{
+const Bufbyte *ptr;
+Bytecount len;
+if (source_type == DFC_TYPE_LISP_STRING)
+	{
+	  ptr = XSTRING_DATA   (source->lisp_object);
+	  len = XSTRING_LENGTH (source->lisp_object);
+	}
+else
+	{
+	  ptr = (Bufbyte *) source->data.ptr;
+	  len = source->data.len;
+	}
+#ifdef MULE
+{
+	const Bufbyte *end;
+	for (end = ptr + len; ptr < end;)
+	  {
+	    Bufbyte c =
+	      (BYTE_ASCII_P (*ptr))		   ? *ptr :
+	      (*ptr == LEADING_BYTE_CONTROL_1)	   ? (*(ptr+1) - 0x20) :
+	      (*ptr == LEADING_BYTE_LATIN_ISO8859_1) ? (*(ptr+1)) :
+	      '~';
+	    Dynarr_add (conversion_out_dynarr, (Extbyte) c);
+	    INC_CHARPTR (ptr);
+	  }
+	bufpos_checking_assert (ptr == end);
+}
+#else
+Dynarr_add_many (conversion_out_dynarr, ptr, len);
+#endif
+}
+else
+{
+Lisp_Object streams_to_delete[3];
+int delete_count = 0;
+Lisp_Object instream, outstream;
+Lstream *reader, *writer;
+struct gcpro gcpro1, gcpro2;
+if (source_type == DFC_TYPE_LISP_LSTREAM)
+	instream = source->lisp_object;
+else if (source_type == DFC_TYPE_DATA)
+	streams_to_delete[delete_count++] = instream =
+	  make_fixed_buffer_input_stream (source->data.ptr, source->data.len);
+else
+	{
+	  type_checking_assert (source_type == DFC_TYPE_LISP_STRING);
+	  streams_to_delete[delete_count++] = instream =
+	    make_lisp_string_input_stream (source->lisp_object, 0, -1);
+	}
+if (sink_type == DFC_TYPE_LISP_LSTREAM)
+	outstream = sink->lisp_object;
+else
+	{
+	  type_checking_assert (sink_type == DFC_TYPE_DATA);
+	  streams_to_delete[delete_count++] = outstream =
+	    make_dynarr_output_stream
+	    ((unsigned_char_dynarr *) conversion_out_dynarr);
+	}
+#ifdef FILE_CODING
+streams_to_delete[delete_count++] = outstream =
+	make_encoding_output_stream (XLSTREAM (outstream), coding_system);
+#endif
+reader = XLSTREAM (instream);
+writer = XLSTREAM (outstream);
+/* decoding_stream will gc-protect outstream */
+GCPRO2 (instream, outstream);
+while (1)
+{
+ssize_t size_in_bytes;
+	  char tempbuf[1024]; /* some random amount */
+	  size_in_bytes = Lstream_read (reader, tempbuf, sizeof (tempbuf));
+if (size_in_bytes == 0)
+break;
+	  else if (size_in_bytes < 0)
+	    error ("Error converting to external format");
+	  size_in_bytes = Lstream_write (writer, tempbuf, size_in_bytes);
+	  if (size_in_bytes <= 0)
+	    error ("Error converting to external format");
+}
+/* Closing writer will close any stream at the other end of writer. */
+Lstream_close (writer);
+Lstream_close (reader);
+UNGCPRO;
+/* The idea is that this function will create no garbage. */
+while (delete_count)
+	Lstream_delete (XLSTREAM (streams_to_delete [--delete_count]));
+}
+unbind_to (count, Qnil);
+if (sink_type != DFC_TYPE_LISP_LSTREAM)
+{
+sink->data.len = Dynarr_length (conversion_out_dynarr);
+Dynarr_add (conversion_out_dynarr, 0);
+sink->data.ptr = Dynarr_atp (conversion_out_dynarr, 0);
+}
+}
+void
+dfc_convert_to_internal_format (dfc_conversion_type source_type,
+				dfc_conversion_data *source,
+#ifdef FILE_CODING
+				Lisp_Object coding_system,
+#endif
+				dfc_conversion_type sink_type,
+				dfc_conversion_data *sink)
+{
+int count = specpdl_depth ();
+type_checking_assert
+((source_type == DFC_TYPE_DATA ||
+source_type == DFC_TYPE_LISP_LSTREAM)
+&&
+(sink_type   == DFC_TYPE_DATA ||
+sink_type   == DFC_TYPE_LISP_LSTREAM));
+if (dfc_convert_to_internal_format_in_use != 0)
+error ("Can't call a conversion function from a conversion function");
+else
+dfc_convert_to_internal_format_in_use = 1;
+record_unwind_protect (dfc_convert_to_internal_format_reset_in_use,
+			 Qzero);
+#ifdef FILE_CODING
+coding_system = Fget_coding_system (coding_system);
+#endif
+Dynarr_reset (conversion_in_dynarr);
+if (source_type != DFC_TYPE_LISP_LSTREAM &&
+sink_type   != DFC_TYPE_LISP_LSTREAM &&
+coding_system_is_binary (coding_system))
+{
+#ifdef MULE
+const Bufbyte *ptr = (const Bufbyte *) source->data.ptr;
+Bytecount len = source->data.len;
+const Bufbyte *end = ptr + len;
+for (; ptr < end; ptr++)
+{
+Extbyte c = *ptr;
+	  if (BYTE_ASCII_P (c))
+	    Dynarr_add (conversion_in_dynarr, c);
+	  else if (BYTE_C1_P (c))
+	    {
+	      Dynarr_add (conversion_in_dynarr, LEADING_BYTE_CONTROL_1);
+	      Dynarr_add (conversion_in_dynarr, c + 0x20);
+	    }
+	  else
+	    {
+	      Dynarr_add (conversion_in_dynarr, LEADING_BYTE_LATIN_ISO8859_1);
+	      Dynarr_add (conversion_in_dynarr, c);
+	    }
+}
+#else
+Dynarr_add_many (conversion_in_dynarr, source->data.ptr, source->data.len);
+#endif
+}
+else
+{
+Lisp_Object streams_to_delete[3];
+int delete_count = 0;
+Lisp_Object instream, outstream;
+Lstream *reader, *writer;
+struct gcpro gcpro1, gcpro2;
+if (source_type == DFC_TYPE_LISP_LSTREAM)
+	instream = source->lisp_object;
+else
+	{
+	  type_checking_assert (source_type == DFC_TYPE_DATA);
+	  streams_to_delete[delete_count++] = instream =
+	    make_fixed_buffer_input_stream (source->data.ptr, source->data.len);
+	}
+if (sink_type == DFC_TYPE_LISP_LSTREAM)
+	outstream = sink->lisp_object;
+else
+	{
+	  type_checking_assert (sink_type == DFC_TYPE_DATA);
+	  streams_to_delete[delete_count++] = outstream =
+	    make_dynarr_output_stream
+	    ((unsigned_char_dynarr *) conversion_in_dynarr);
+	}
+#ifdef FILE_CODING
+streams_to_delete[delete_count++] = outstream =
+	make_decoding_output_stream (XLSTREAM (outstream), coding_system);
+#endif
+reader = XLSTREAM (instream);
+writer = XLSTREAM (outstream);
+/* outstream will gc-protect its sink stream, if necessary */
+GCPRO2 (instream, outstream);
+while (1)
+{
+ssize_t size_in_bytes;
+	  char tempbuf[1024]; /* some random amount */
+	  size_in_bytes = Lstream_read (reader, tempbuf, sizeof (tempbuf));
+if (size_in_bytes == 0)
+break;
+	  else if (size_in_bytes < 0)
+	    error ("Error converting to internal format");
+	  size_in_bytes = Lstream_write (writer, tempbuf, size_in_bytes);
+	  if (size_in_bytes <= 0)
+	    error ("Error converting to internal format");
+}
+/* Closing writer will close any stream at the other end of writer. */
+Lstream_close (writer);
+Lstream_close (reader);
+UNGCPRO;
+/* The idea is that this function will create no garbage. */
+while (delete_count)
+	Lstream_delete (XLSTREAM (streams_to_delete [--delete_count]));
+}
+unbind_to (count, Qnil);
+if (sink_type != DFC_TYPE_LISP_LSTREAM)
+{
+sink->data.len = Dynarr_length (conversion_in_dynarr);
+Dynarr_add (conversion_in_dynarr, 0); /* remember to zero-terminate! */
+sink->data.ptr = Dynarr_atp (conversion_in_dynarr, 0);
+}
+}
 void
 syms_of_buffer (void)
 {
 defsymbol (&Qbuffer_live_p, "buffer-live-p");
 }
 void
 reinit_vars_of_buffer (void)
 {
+conversion_in_dynarr  = Dynarr_new (Bufbyte);
+conversion_out_dynarr = Dynarr_new (Extbyte);
 staticpro_nodump (&Vbuffer_alist);
 Vbuffer_alist = Qnil;
 current_buffer = 0;
 }
 	  BUFFER_SLOTS_SIZE);
 }
 static const struct lrecord_description buffer_slots_description_1[] = {
-{ XD_LISP_OBJECT, 0, BUFFER_SLOTS_COUNT },
+{ XD_LISP_OBJECT_ARRAY, 0, BUFFER_SLOTS_COUNT },
 { XD_END }
 };
 static const struct struct_description buffer_slots_description = {
 BUFFER_SLOTS_SIZE,
 syms = XBUFFER (Vbuffer_local_symbols);
 buffer_defaults_saved_slots      = &defs->BUFFER_SLOTS_FIRST_NAME;
 buffer_local_symbols_saved_slots = &syms->BUFFER_SLOTS_FIRST_NAME;
 dumpstruct (&buffer_defaults_saved_slots,      &buffer_slots_description);
 dumpstruct (&buffer_local_symbols_saved_slots, &buffer_slots_description);
 DEFVAR_BUFFER_DEFAULTS ("default-modeline-format", modeline_format /*
 Default value of `modeline-format' for buffers that don't override it.
 This is the same as (default-value 'modeline-format).
 */ );
 }
 }
 /* Is PWD another name for `.' ? */
 static int
-directory_is_current_directory (char *pwd)
+directory_is_current_directory (Extbyte *pwd)
 {
 Bufbyte *pwd_internal;
+Bytecount pwd_internal_len;
 struct stat dotstat, pwdstat;
-GET_C_CHARPTR_INT_FILENAME_DATA_ALLOCA (pwd, pwd_internal);
+TO_INTERNAL_FORMAT (DATA, (pwd, strlen ((char *)pwd) + 1),
+		      ALLOCA, (pwd_internal, pwd_internal_len),
+		      Qfile_name);
 return (IS_DIRECTORY_SEP (*pwd_internal)
 	  && stat ((char *) pwd_internal, &pwdstat) == 0
 	  && stat (".", &dotstat) == 0
 	  && dotstat.st_ino == pwdstat.st_ino
 	  && dotstat.st_dev == pwdstat.st_dev
-	  && (int) strlen ((char *) pwd_internal) < MAXPATHLEN);
+	  && pwd_internal_len < MAXPATHLEN);
 }
 void
 init_initial_directory (void)
 {
 /* This function can GC */
-char *pwd;
+Extbyte *pwd;
 initial_directory[0] = 0;
 /* If PWD is accurate, use it instead of calling getcwd.  This is faster
 when PWD is right, and may avoid a fatal error.  */
-if ((pwd = getenv ("PWD")) != NULL
+if ((pwd = (Extbyte *) getenv ("PWD")) != NULL
 && directory_is_current_directory (pwd))
-strcpy (initial_directory, pwd);
+strcpy (initial_directory, (char *) pwd);
 else if (getcwd (initial_directory, MAXPATHLEN) == NULL)
 fatal ("`getcwd' failed: %s\n", strerror (errno));
 /* Make sure pwd is DIRECTORY_SEP-terminated.
 Maybe this should really use some standard subroutine
 /* This function can GC */
 Fset_buffer (Fget_buffer_create (QSscratch));
 current_buffer->directory =
-build_ext_string (initial_directory, FORMAT_FILENAME);
+build_ext_string (initial_directory, Qfile_name);
 #if 0 /* FSFmacs */
 /* #### is this correct? */
 temp = get_minibuffer (0);
 XBUFFER (temp)->directory = current_buffer->directory;

Mercurial > hg > xemacs-beta

comparison src/buffer.c @ 440:8de8e3f6228a r21-2-28