comparison src/fileio.c @ 38450:8416a4627a13

(unwind_read): Function removed. (read_non_regular, read_non_regular_quit): New functions. (Finsert_file_contents): When reading from non-regular files, arrange to catch a `quit' and terminate the loop. Rearrange code so that a `quit' when reading from a regular file doesn't insert text in the buffer.

38449:2f7725eae50d

  return Qnil;
}


/* Unwind-function for reading from a file in insert-file-contents.

   INSERTED_BYTES is the number of bytes successfully inserted into
   current_buffer.

   When reading is interrupted by C-g, this leaves the newly read part
   of the current buffer undecoded.  If this happens in a multibyte
   buffer, prevent invalid characters by either discarding what has
   been read or switching the buffer to unibyte.

           PT                 GPT
   +-----------------------------------------------------+
   |       |  inserted bytes   |  GAP_SIZE |             |
   +-----------------------------------------------------+
           \                             /
	    +--------- the gap ---------+	 */

static Lisp_Object
unwind_read (inserted_bytes)
     Lisp_Object inserted_bytes;
{
  if (!NILP (current_buffer->enable_multibyte_characters))
    {
      int nbytes = XINT (inserted_bytes);
      Lisp_Object args[3];
      char *action;

      if (Z == nbytes)
	{
	  /* Buffer was previously empty.  Switch it to unibyte
	     because newly inserted text is not decoded.  */
	  current_buffer->enable_multibyte_characters = Qnil;
	  action = "buffer made unibyte";
	}
      else
	{
	  ZV -= nbytes;
	  ZV_BYTE -= nbytes;
	  Z -= nbytes;
	  Z_BYTE -= nbytes;
      
	  GPT = PT;
	  GPT_BYTE = PT_BYTE;
	  GAP_SIZE = nbytes + GAP_SIZE;
	  
	  action = "no text inserted";
	}

      
      args[0] = build_string ("Quit while inserting text in buffer `%s': %s");
      args[1] = current_buffer->name;
      args[2] = build_string (action);
      Fmessage (3, args);
    }
      
  return Qnil;
}


DEFUN ("insert-file-contents", Finsert_file_contents, Sinsert_file_contents,

  struct coding_system coding;
  unsigned char buffer[1 << 14];
  int replace_handled = 0;
  int set_coding_system = 0;
  int coding_system_decided = 0;

  if (current_buffer->base_buffer && ! NILP (visit))
    error ("Cannot do file visiting in an indirect buffer");

  if (!NILP (current_buffer->read_only))

  /* In the following loop, HOW_MUCH contains the total bytes read so
     far for a regular file, and not changed for a special file.  But,
     before exiting the loop, it is set to a negative value if I/O
     error occurs.  */
  how_much = 0;
  /* Total bytes inserted.  */
  inserted = 0;
  /* Here, we don't do code conversion in the loop.  It is done by
     code_convert_region after all data are read into the buffer.  */
  while (how_much < total)
    {
	/* try is reserved in some compilers (Microsoft C) */
      int trytry = min (total - how_much, READ_BUF_SIZE);
      int this;
      int count = BINDING_STACK_SIZE ();

      /* For a special file, GAP_SIZE should be checked every time.  */
      if (not_regular && GAP_SIZE < trytry)
	make_gap (total - GAP_SIZE);

      /* Allow quitting out of the actual I/O.  If a C-g interrupts
	 this, make sure that no invalid characters remain
	 in the undecoded part read.  */
      record_unwind_protect (unwind_read, make_number (inserted));
      immediate_quit = 1;
      QUIT;
      this = emacs_read (fd, BYTE_POS_ADDR (PT_BYTE + inserted - 1) + 1,
			 trytry);
      immediate_quit = 0;
      --specpdl_ptr;

      if (this <= 0)
	{
	  how_much = this;
	  break;
	}

      GAP_SIZE -= this;
      GPT_BYTE += this;
      ZV_BYTE += this;
      Z_BYTE += this;
      GPT += this;
      ZV += this;
      Z += this;

      /* For a regular file, where TOTAL is the real size,
	 count HOW_MUCH to compare with it.
	 For a special file, where TOTAL is just a buffer size,
	 so don't bother counting in HOW_MUCH.
	 (INSERTED is where we count the number of characters inserted.)  */
      if (! not_regular)
	how_much += this;
      inserted += this;
    }

  if (GAP_SIZE > 0)
    /* Put an anchor to ensure multi-byte form ends at gap.  */
    *GPT_ADDR = 0;

      && current_buffer->modtime == -1)
    {
      /* If visiting nonexistent file, return nil.  */
      report_file_error ("Opening input file", Fcons (orig_filename, Qnil));
    }

  /* ??? Retval needs to be dealt with in all cases consistently.  */
  if (NILP (val))
    val = Fcons (orig_filename,
		 Fcons (make_number (inserted),

38450:8416a4627a13

  return Qnil;
}


/* Used to pass values from insert-file-contents to read_non_regular.  */

static int non_regular_fd;
static int non_regular_inserted;
static int non_regular_nbytes;


/* Read from a non-regular file.
   Read non_regular_trytry bytes max from non_regular_fd.
   Non_regular_inserted specifies where to put the read bytes.
   Value is the number of bytes read.  */

static Lisp_Object
read_non_regular ()
{
  int nbytes;
  
  immediate_quit = 1;
  QUIT;
  nbytes = emacs_read (non_regular_fd,
		       BEG_ADDR + PT_BYTE - 1 + non_regular_inserted,
		       non_regular_nbytes);
  Fsignal (Qquit, Qnil);
  immediate_quit = 0;
  return make_number (nbytes);
}


/* Condition-case handler used when reading from non-regular files
   in insert-file-contents.  */

static Lisp_Object
read_non_regular_quit ()
{
  return Qnil;
}


DEFUN ("insert-file-contents", Finsert_file_contents, Sinsert_file_contents,

  struct coding_system coding;
  unsigned char buffer[1 << 14];
  int replace_handled = 0;
  int set_coding_system = 0;
  int coding_system_decided = 0;
  int gap_size;
  int read_quit = 0;

  if (current_buffer->base_buffer && ! NILP (visit))
    error ("Cannot do file visiting in an indirect buffer");

  if (!NILP (current_buffer->read_only))

  /* In the following loop, HOW_MUCH contains the total bytes read so
     far for a regular file, and not changed for a special file.  But,
     before exiting the loop, it is set to a negative value if I/O
     error occurs.  */
  how_much = 0;
  
  /* Total bytes inserted.  */
  inserted = 0;
  
  /* Here, we don't do code conversion in the loop.  It is done by
     code_convert_region after all data are read into the buffer.  */
  {
    int gap_size = GAP_SIZE;
    
    while (how_much < total)
      {
	/* try is reserved in some compilers (Microsoft C) */
	int trytry = min (total - how_much, READ_BUF_SIZE);
	int this;

	if (not_regular)
	  {
	    Lisp_Object val;

	    /* Maybe make more room.  */
	    if (gap_size < trytry)
	      {
		make_gap (total - gap_size);
		gap_size = GAP_SIZE;
	      }

	    /* Read from the file, capturing `quit'.  When an
	       error occurs, end the loop, and arrange for a quit
	       to be signaled after decoding the text we read.  */
	    non_regular_fd = fd;
	    non_regular_inserted = inserted;
	    non_regular_nbytes = trytry;
	    val = internal_condition_case_1 (read_non_regular, Qnil, Qerror,
					     read_non_regular_quit);
	    if (NILP (val))
	      {
		read_quit = 1;
		break;
	      }

	    this = XINT (val);
	  }
	else
	  {
	    /* Allow quitting out of the actual I/O.  We don't make text
	       part of the buffer until all the reading is done, so a C-g
	       here doesn't do any harm.  */
	    immediate_quit = 1;
	    QUIT;
	    this = emacs_read (fd, BEG_ADDR + PT_BYTE - 1 + inserted, trytry);
	    immediate_quit = 0;
	  }
      
	if (this <= 0)
	  {
	    how_much = this;
	    break;
	  }

	gap_size -= this;

	/* For a regular file, where TOTAL is the real size,
	   count HOW_MUCH to compare with it.
	   For a special file, where TOTAL is just a buffer size,
	   so don't bother counting in HOW_MUCH.
	   (INSERTED is where we count the number of characters inserted.)  */
	if (! not_regular)
	  how_much += this;
	inserted += this;
      }
  }

  /* Make the text read part of the buffer.  */
  GAP_SIZE -= inserted;
  GPT      += inserted;
  GPT_BYTE += inserted;
  ZV       += inserted;
  ZV_BYTE  += inserted;
  Z        += inserted;
  Z_BYTE   += inserted;

  if (GAP_SIZE > 0)
    /* Put an anchor to ensure multi-byte form ends at gap.  */
    *GPT_ADDR = 0;

      && current_buffer->modtime == -1)
    {
      /* If visiting nonexistent file, return nil.  */
      report_file_error ("Opening input file", Fcons (orig_filename, Qnil));
    }

  if (read_quit)
    Fsignal (Qquit, Qnil);

  /* ??? Retval needs to be dealt with in all cases consistently.  */
  if (NILP (val))
    val = Fcons (orig_filename,
		 Fcons (make_number (inserted),