xemacs-beta: src/fileio.c comparison

comparison src/fileio.c @ 40:7e54bd776075 r19-15b103

Import from CVS: tag r19-15b103

author	cvs
date	Mon, 13 Aug 2007 08:54:25 +0200
parents	e04119814345
children	8d2a9b52c682

comparison

equal deleted inserted replaced

-:06f275776fba
+:7e54bd776075
 /* signal a file error when errno contains a meaningful value. */
 DOESNT_RETURN
 report_file_error (CONST char *string, Lisp_Object data)
 {
+/* #### dmoore - This uses current_buffer, better make sure no one
+has GC'd the current buffer.  File handlers are giving me a headache
+maybe I'll just always protect current_buffer around all of those
+calls. */
 /* mrb: #### Needs to be fixed at a lower level; errstring needs to
 be MULEized.  The following at least prevents a crash... */
 Lisp_Object errstring = build_ext_string (strerror (errno), FORMAT_BINARY);
 /* System error messages are capitalized.  Downcase the initial
 CHECK_STRING (result);
 return (result);
 }
 static Lisp_Object
+call2_check_string_or_nil (Lisp_Object fn, Lisp_Object arg0, Lisp_Object arg1)
+{
+/* This function can GC */
+Lisp_Object result = call2 (fn, arg0, arg1);
+if (!NILP (result))
+CHECK_STRING (result);
+return (result);
+}
+static Lisp_Object
 call3_check_string (Lisp_Object fn, Lisp_Object arg0,
 Lisp_Object arg1, Lisp_Object arg2)
 {
 /* This function can GC */
 Lisp_Object result = call3 (fn, arg0, arg1, arg2);
 /* If the file name has special constructs in it,
 call the corresponding file handler.  */
 handler = Ffind_file_name_handler (file, Qfile_name_directory);
 if (!NILP (handler))
-{
+return (call2_check_string_or_nil (handler, Qfile_name_directory,
-Lisp_Object retval = call2 (handler, Qfile_name_directory,
+				       file));
-				  file);
-if (!NILP (retval))
-	CHECK_STRING (retval);
-return retval;
-}
 #ifdef FILE_SYSTEM_CASE
 file = FILE_SYSTEM_CASE (file);
 #endif
 beg = XSTRING_DATA (file);
 int drive = -1;
 int relpath = 0;
 Bufbyte *tmp, *defdir;
 #endif /* DOS_NT */
 Lisp_Object handler;
+struct gcpro gcpro1;
 CHECK_STRING (name);
 /* If the file name has special constructs in it,
 call the corresponding file handler.  */
 else
 CHECK_STRING (defalt);
 if (!NILP (defalt))
 {
+struct gcpro gcpro1;
+GCPRO1 (defalt);		/* might be current_buffer->directory */
 handler = Ffind_file_name_handler (defalt, Qexpand_file_name);
+UNGCPRO;
 if (!NILP (handler))
 	return call3 (handler, Qexpand_file_name, name, defalt);
 }
 /* Make sure DEFALT is properly expanded.
 	    && IS_DIRECTORY_SEP (XSTRING_BYTE (defalt, 0))
 	    && IS_DEVICE_SEP (XSTRING_BYTE (defalt, 1))))
 {
 struct gcpro gcpro1;
-GCPRO1 (name);
+GCPRO1 (defalt);		/* may be current_buffer->directory */
 defalt = Fexpand_file_name (defalt, Qnil);
 UNGCPRO;
 }
 #ifdef VMS
 #endif
 #ifdef FILE_SYSTEM_CASE
 name = FILE_SYSTEM_CASE (name);
 #endif
+/* #### dmoore - this is ugly, clean this up.  Looks like nm
+pointing into name should be safe during all of this, though. */
 nm = XSTRING_DATA (name);
 #ifdef MSDOS
 /* First map all backslashes to slashes.  */
 dostounix_filename (nm = strcpy (alloca (strlen (nm) + 1), nm));
 Lisp_Object expanded_name;
 Lisp_Object handler;
 CHECK_STRING (filename);
-GCPRO1 (filename);
 expanded_name = Fexpand_file_name (filename, defalt);
-UNGCPRO;
 if (!STRINGP (expanded_name))
 return Qnil;
 GCPRO1 (expanded_name);
 /* If the file name has special constructs in it,
 call the corresponding file handler.  */
 handler = Ffind_file_name_handler (string, Qsubstitute_in_file_name);
 if (!NILP (handler))
-{
+return (call2_check_string_or_nil (handler, Qsubstitute_in_file_name,
-Lisp_Object retval = call2 (handler, Qsubstitute_in_file_name,
+				       string));
-				  string);
-if (!NILP (retval))
-	CHECK_STRING (retval);
-return retval;
-}
 nm = XSTRING_DATA (string);
 #ifdef MSDOS
 dostounix_filename (nm = strcpy (alloca (strlen (nm) + 1), nm));
 substituted = !strcmp (nm, XSTRING_DATA (string));
 (dirname))
 {
 /* This function can GC */
 char dir [MAXPATHLEN];
 Lisp_Object handler;
 struct gcpro gcpro1;
-GCPRO1 (dirname);
 CHECK_STRING (dirname);
 dirname = Fexpand_file_name (dirname, Qnil);
+GCPRO1 (dirname);
 handler = Ffind_file_name_handler (dirname, Qmake_directory_internal);
 UNGCPRO;
 if (!NILP (handler))
-return (call2 (handler, Qmake_directory_internal,
+return (call2 (handler, Qmake_directory_internal, dirname));
-		   dirname));
 if (XSTRING_LENGTH (dirname) > (sizeof (dir) - 1))
 {
 return Fsignal (Qfile_error,
 		      list3 (build_translated_string ("Creating directory"),
 {
 /* This function can GC */
 Lisp_Object handler;
 struct gcpro gcpro1;
+CHECK_STRING (dirname);
 GCPRO1 (dirname);
-CHECK_STRING (dirname);
+dirname = Fexpand_file_name (dirname, Qnil);
-dirname =
+dirname =  Fdirectory_file_name (dirname);
-Fdirectory_file_name (Fexpand_file_name (dirname, Qnil));
 handler = Ffind_file_name_handler (dirname, Qdelete_directory);
 UNGCPRO;
 if (!NILP (handler))
 return (call2 (handler, Qdelete_directory, dirname));
 {
 /* This function can GC */
 Lisp_Object handler;
 struct gcpro gcpro1;
-GCPRO1 (filename);
 CHECK_STRING (filename);
 filename = Fexpand_file_name (filename, Qnil);
+GCPRO1 (filename);
 handler = Ffind_file_name_handler (filename, Qdelete_file);
 UNGCPRO;
 if (!NILP (handler))
 return call2 (handler, Qdelete_file, filename);
 if (stat ((char *) XSTRING_DATA (abspath), &statbuf) >= 0)
 return (check_writable ((char *) XSTRING_DATA (abspath))
 	    ? Qt : Qnil);
+GCPRO1 (abspath);
 dir = Ffile_name_directory (abspath);
+UNGCPRO;
 #if defined (VMS) || defined (MSDOS)
 if (!NILP (dir))
-dir = Fdirectory_file_name (dir);
+{
+GCPRO1(dir);
+dir = Fdirectory_file_name (dir);
+UNGCPRO;
+}
 #endif /* VMS or MSDOS */
 return (check_writable (!NILP (dir) ? (char *) XSTRING_DATA (dir)
 			  : "")
 	  ? Qt : Qnil);
 }
 Lisp_Object abspath;
 struct stat st;
 Lisp_Object handler;
 struct gcpro gcpro1;
-GCPRO1 (filename);
+GCPRO1 (current_buffer->directory);
 abspath = expand_and_dir_to_file (filename,
 				    current_buffer->directory);
 UNGCPRO;
 /* If the file name has special constructs in it,
 handler = Ffind_file_name_handler (filename, Qfile_accessible_directory_p);
 if (!NILP (handler))
 return call2 (handler, Qfile_accessible_directory_p,
 		  filename);
+/* #### dmoore - this gcpro on filename should be unneccesary since
+the caller should ahve already protected it. */
 GCPRO1 (filename);
 if (NILP (Ffile_directory_p (filename)))
 {
 UNGCPRO;
 return (Qnil);
 "Return t if file FILENAME is the name of a regular file.
 This is the sort of file that holds an ordinary stream of data bytes.
 */
 (filename))
 {
-REGISTER Lisp_Object abspath;
+Lisp_Object abspath;
 struct stat st;
 Lisp_Object handler;
+struct gcpro gcpro1;
+GCPRO1 (current_buffer->directory);
 abspath = expand_and_dir_to_file (filename, current_buffer->directory);
+UNGCPRO;
 /* If the file name has special constructs in it,
 call the corresponding file handler.  */
+GCPRO1 (abspath);
 handler = Ffind_file_name_handler (abspath, Qfile_regular_p);
+UNGCPRO;
 if (!NILP (handler))
 return call2 (handler, Qfile_regular_p, abspath);
 if (stat ((char *) XSTRING_DATA (abspath), &st) < 0)
 return Qnil;
 Lisp_Object abspath;
 struct stat st;
 Lisp_Object handler;
 struct gcpro gcpro1;
-GCPRO1 (filename);
+GCPRO1 (current_buffer->directory);
 abspath = expand_and_dir_to_file (filename,
 				    current_buffer->directory);
 UNGCPRO;
 /* If the file name has special constructs in it,
 (filename, mode))
 {
 /* This function can GC */
 Lisp_Object abspath;
 Lisp_Object handler;
-struct gcpro gcpro1, gcpro2;
+struct gcpro gcpro1;
-GCPRO2 (filename, mode);
+GCPRO1 (current_buffer->directory);
 abspath = Fexpand_file_name (filename, current_buffer->directory);
 CHECK_INT (mode);
 UNGCPRO;
 /* If the file name has special constructs in it,
 /* This function can GC */
 Lisp_Object abspath1, abspath2;
 struct stat st;
 int mtime1;
 Lisp_Object handler;
-struct gcpro gcpro1, gcpro2;
+struct gcpro gcpro1, gcpro2, gcpro3;
 CHECK_STRING (file1);
 CHECK_STRING (file2);
 abspath1 = Qnil;
-GCPRO2 (abspath1, file2);
+abspath2 = Qnil;
-abspath1 = expand_and_dir_to_file (file1,
-				     current_buffer->directory);
+GCPRO3 (abspath1, abspath2, current_buffer->directory);
-abspath2 = expand_and_dir_to_file (file2,
+abspath1 = expand_and_dir_to_file (file1, current_buffer->directory);
-				     current_buffer->directory);
+abspath2 = expand_and_dir_to_file (file2, current_buffer->directory);
-UNGCPRO;
 /* If the file name has special constructs in it,
 call the corresponding file handler.  */
-GCPRO2 (abspath1, abspath2);
 handler = Ffind_file_name_handler (abspath1, Qfile_newer_than_file_p);
 if (NILP (handler))
 handler = Ffind_file_name_handler (abspath2, Qfile_newer_than_file_p);
 UNGCPRO;
 if (!NILP (handler))
 struct stat st;
 int fd;
 int saverrno = 0;
 Charcount inserted = 0;
 int speccount;
-struct gcpro gcpro1, gcpro2, gcpro3, gcpro4;
+struct gcpro gcpro1, gcpro2, gcpro3, gcpro4, gcpro5;
 Lisp_Object handler = Qnil, val;
 int total;
 Bufbyte read_buf[READ_BUF_SIZE];
 int mc_count;
 struct buffer *buf = current_buffer;
+Lisp_Object curbuf;
 int not_regular = 0;
 if (buf->base_buffer && ! NILP (visit))
 error ("Cannot do file visiting in an indirect buffer");
 /* No need to call Fbarf_if_buffer_read_only() here.
 That's called in begin_multiple_change() or wherever. */
 val = Qnil;
-GCPRO4 (filename, val, visit, handler);
+/* #### dmoore - should probably check in various places to see if
+curbuf was killed and if so signal an error? */
+XSETBUFFER (curbuf, buf);
+GCPRO5 (filename, val, visit, handler, curbuf);
 mc_count = (NILP (replace)) ?
 begin_multiple_change (buf, BUF_PT  (buf), BUF_PT (buf)) :
 begin_multiple_change (buf, BUF_BEG (buf), BUF_Z  (buf));
 Lisp_Object visit_file = Qnil;
 Lisp_Object annotations = Qnil;
 struct buffer *given_buffer;
 Bufpos start1, end1;
+/* #### dmoore - if Fexpand_file_name or handlers kill the buffer,
+we should signal an error rather than blissfully continuing
+along.  ARGH, this function is going to lose lose lose.  We need
+to protect the current_buffer from being destroyed, but the
+multiple return points make this a pain in the butt. */
 #ifdef DOS_NT
 int buffer_file_type
 = NILP (current_buffer->buffer_file_type) ? O_TEXT : O_BINARY;
 #endif /* DOS_NT */
 get_buffer_range_char (current_buffer, start, end, &start1, &end1, 0);
 {
 Lisp_Object handler;
 struct gcpro gcpro1, gcpro2, gcpro3, gcpro4, gcpro5;
 GCPRO5 (start, filename, visit, visit_file, lockname);
 if (visiting_other)
 visit_file = Fexpand_file_name (visit, Qnil);
 else
 }
 #ifdef CLASH_DETECTION
 if (!auto_saving)
 {
-struct gcpro gcpro1, gcpro2, gcpro3, gcpro4;
+Lisp_Object curbuf;
-GCPRO4 (start, filename, visit_file, lockname);
+struct gcpro gcpro1, gcpro2, gcpro3, gcpro4, gcpro5;
+XSETBUFFER (curbuf, current_buffer);
+GCPRO5 (start, filename, visit_file, lockname, curbuf);
 lock_file (lockname);
 UNGCPRO;
 }
 #endif /* CLASH_DETECTION */
 else
 {
 Lisp_Object filename;
 struct stat st;
 Lisp_Object handler;
-struct gcpro gcpro1, gcpro2;
+struct gcpro gcpro1, gcpro2, gcpro3;
-GCPRO2 (filename, time_list);
+GCPRO3 (filename, time_list, current_buffer->filename);
-filename = Fexpand_file_name (current_buffer->filename,
+filename = Fexpand_file_name (current_buffer->filename, Qnil);
-				    Qnil);
 /* If the file name has special constructs in it,
 	 call the corresponding file handler.  */
 handler = Ffind_file_name_handler (filename, Qset_visited_file_modtime);
 UNGCPRO;
 }
 if (!set_time_to_use)
 {
 Lisp_Object filename = Qnil;
-struct gcpro gcpro1, gcpro2;
+struct gcpro gcpro1;
-GCPRO2 (buf, filename);
+GCPRO1 (filename);
+/* #### dmoore - do we need to protect XBUFFER (buf)->filename?
+	 What if a ^(*&^&*^*& handler renames a buffer?  I think I'm
+	 getting a headache now. */
 if (STRINGP (XBUFFER (buf)->filename))
-filename = Fexpand_file_name (XBUFFER (buf)->filename,
+filename = Fexpand_file_name (XBUFFER (buf)->filename, Qnil);
-				      Qnil);
 else
 filename = Qnil;
-UNGCPRO;
 if (!NILP (filename) && !NILP (Ffile_exists_p (filename)))
 {
 	  Lisp_Object handler;
 	  /* If the file name has special constructs in it,
 	     call the corresponding file handler.  */
-	  GCPRO1 (filename);
 	  handler = Ffind_file_name_handler (filename, Qset_buffer_modtime);
 	  UNGCPRO;
 	  if (!NILP (handler))
 	    /* The handler can find the file name the same way we did. */
 	    return (call2 (handler, Qset_buffer_modtime, Qnil));
 	      else
 		time_to_use = time ((time_t *) 0);
 	    }
 }
 else
-	time_to_use = time ((time_t *) 0);
+	{
+	  UNGCPRO;
+	  time_to_use = time ((time_t *) 0);
+	}
 }
 XBUFFER (buf)->modtime = time_to_use;
 return Qnil;
 }
 static Lisp_Object

Mercurial > hg > xemacs-beta

comparison src/fileio.c @ 40:7e54bd776075 r19-15b103