comparison src/keyboard.c @ 83067:b44978264e1d

Merged in changes from CVS HEAD Patches applied: * [e-mail]--gnu-2004/emacs--cvs-trunk--0--patch-118 Update from CVS * [e-mail]--gnu-2004/emacs--cvs-trunk--0--patch-119 src/keyboard.c (adjust_point_for_property): #ifdef-out dodgy xassert * [e-mail]--gnu-2004/emacs--cvs-trunk--0--patch-120 Update from CVS git-archimport-id: [e-mail]--2004/emacs--multi-tty--0--patch-107

83066:887bb2eb4a89

			 was already in the range: we don't get to choose
			 which end of the range we have to go to.  */
		      : (PT < last_pt ? beg : end));
	      check_composition = check_display = 1;
	    }
	  xassert (PT == beg || PT == end);
	  /* Pretend the area doesn't exist if the buffer is not
	     modified.  */
	  if (!modified && !ellipsis && beg < end)
	    {
	      if (last_pt == beg && PT == end && end < ZV)

void
kbd_buffer_store_event (event)
     register struct input_event *event;
{
  if (event->kind == NO_EVENT)
    abort ();

  if (event->kind == ASCII_KEYSTROKE_EVENT)
    {
      register int c = event->code & 0377;

		}
	      return;
	    }
#endif

	  /* If this results in a quit_char being returned to Emacs as
	     input, set Vlast_event_frame properly.  If this doesn't
	     get returned to Emacs as an event, the next event read
	     will set Vlast_event_frame again, so this is safe to do.  */
	  {

    }
  /* Don't insert two BUFFER_SWITCH_EVENT's in a row.
     Just ignore the second one.  */
  else if (event->kind == BUFFER_SWITCH_EVENT
	   && kbd_fetch_ptr != kbd_store_ptr
	   && kbd_store_ptr->kind == BUFFER_SWITCH_EVENT)
    return;

  if (kbd_store_ptr - kbd_buffer == KBD_BUFFER_SIZE)
    kbd_store_ptr = kbd_buffer;

   overlay, or nil if neither from a string nor from a buffer.  POS is
   the position within OBJECT where the help was found.

   Value is the number of input_events generated.  */

int
gen_help_event (bufp, size, help, frame, window, object, pos)
     struct input_event *bufp;
     int size;
     Lisp_Object help, frame, object, window;
     int pos;
{
  if (size >= 1)
    {
      bufp->kind = HELP_EVENT;
      bufp->frame_or_window = frame;
      bufp->arg = object;
      bufp->x = WINDOWP (window) ? window : frame;
      bufp->y = help;
      bufp->code = pos;
      return 1;
    }
  return 0;
}


/* Store HELP_EVENTs for HELP on FRAME in the input queue.  */

   Except on VMS, all input is read by this function.
   If interrupt_input is nonzero, this function MUST be called
   only when SIGIO is blocked.

   Returns the number of keyboard chars read, or -1 meaning
   this is a bad time to try to read input.

   Typically, there are just a few available input events to be read
   here, so we really don't need to allocate and initialize a big
   buffer of input_events as we used to do.  Instead, we just allocate
   a small buffer of input events -- and then poll for more input if we
   read a full buffer of input events.  */

#define NREAD_INPUT_EVENTS 512

static int
read_avail_input (expected)
     int expected;
{

      if (d->read_socket_hook)
        {
          int discard = 0;
          int nr;

          do {
            struct input_event buf[NREAD_INPUT_EVENTS];

            for (i = 0; i < NREAD_INPUT_EVENTS; i++)
              EVENT_INIT (buf[i]);

            /* No need for FIONREAD or fcntl; just say don't wait.  */
            nr = (*d->read_socket_hook) (d, buf, NREAD_INPUT_EVENTS, expected);

            if (nr > 0)
              {
                /* We've got input. */
                nread += nr;
                expected = 0;

                /* Scan the chars for C-g and store them in kbd_buffer.  */
                for (i = 0; !discard && i < nr; i++)
                  {
                    kbd_buffer_store_event (&buf[i]);
                    /* Don't look at input that follows a C-g too closely.
                       This reduces lossage due to autorepeat on C-g.  */
                    if (buf[i].kind == ASCII_KEYSTROKE_EVENT
                        && buf[i].code == quit_char)
                      discard = 1;
                  }
              }
            else if (nr == -1)          /* Not OK to read input now. */
              {
                err = 1;
              }
            else if (nr == -2)          /* Non-transient error. */
              {
                /* The display device terminated; it should be closed. */

                /* Kill Emacs if this was our last display. */
                if (! display_list->next_display)
                  /* Formerly simply reported no input, but that
                     sometimes led to a failure of Emacs to terminate.
                     SIGHUP seems appropriate if we can't reach the
                     terminal.  */
                  /* ??? Is it really right to send the signal just to
                     this process rather than to the whole process
                     group?  Perhaps on systems with FIONREAD Emacs is
                     alone in its group.  */
                  kill (getpid (), SIGHUP);

                /* XXX Is calling delete_display safe here?  It calls Fdelete_frame. */
                if (d->delete_display_hook)
                  (*d->delete_display_hook) (d);
                else
                  delete_display (d);
              }
          } while (nr == NREAD_INPUT_EVENTS);
        }

      d = next;
    }

   and so this function is called once for each individual termcap
   display.  The first parameter indicates which device to read from.  */

int
tty_read_avail_input (struct display *display,
                      struct input_event *buf,
                      int numchars, int expected)
{
  /* Using numchars here avoids reading more than the buf can
     really hold.  That may prevent loss of characters on some systems
     when input is stuffed at us.  */
  unsigned char cbuf[numchars];
  int n_to_read, i;
  struct tty_display_info *tty = display->display_info.tty;
  int nread = 0;

  if (display->type != output_termcap)

#endif /* not MSDOS */
#endif /* not WINDOWSNT */

  for (i = 0; i < nread; i++)
    {
      buf[i].kind = ASCII_KEYSTROKE_EVENT;
      buf[i].modifiers = 0;
      if (tty->meta_key == 1 && (cbuf[i] & 0x80))
        buf[i].modifiers = meta_modifier;
      if (tty->meta_key != 2)
        cbuf[i] &= ~0x80;

      buf[i].code = cbuf[i];
      /* Set the frame corresponding to the active tty.  Note that the
         value of selected_frame is not reliable here, redisplay tends
         to temporarily change it. */
      buf[i].frame_or_window = tty->top_frame;
      buf[i].arg = Qnil;
    }

  return nread;
}
#endif /* not VMS */

83067:b44978264e1d

			 was already in the range: we don't get to choose
			 which end of the range we have to go to.  */
		      : (PT < last_pt ? beg : end));
	      check_composition = check_display = 1;
	    }
#if 0 /* This assertion isn't correct, because SET_PT may end up setting
	 the point to something other than its argument, due to
	 point-motion hooks, intangibility, etc.  */
	  xassert (PT == beg || PT == end);
#endif

	  /* Pretend the area doesn't exist if the buffer is not
	     modified.  */
	  if (!modified && !ellipsis && beg < end)
	    {
	      if (last_pt == beg && PT == end && end < ZV)

void
kbd_buffer_store_event (event)
     register struct input_event *event;
{
  kbd_buffer_store_event_hold (event, 0);
}

/* Store EVENT obtained at interrupt level into kbd_buffer, fifo.

   If HOLD_QUIT is 0, just stuff EVENT into the fifo.
   Else, if HOLD_QUIT.kind != NO_EVENT, discard EVENT.
   Else, if EVENT is a quit event, store the quit event
   in HOLD_QUIT, and return (thus ignoring further events).

   This is used in read_avail_input to postpone the processing
   of the quit event until all subsequent input events have been
   parsed (and discarded).
 */

void
kbd_buffer_store_event_hold (event, hold_quit)
     register struct input_event *event;
     struct input_event *hold_quit;
{
  if (event->kind == NO_EVENT)
    abort ();

  if (hold_quit && hold_quit->kind != NO_EVENT)
    return;

  if (event->kind == ASCII_KEYSTROKE_EVENT)
    {
      register int c = event->code & 0377;

		}
	      return;
	    }
#endif

	  if (hold_quit)
	    {
	      bcopy (event, (char *) hold_quit, sizeof (*event));
	      return;
	    }

	  /* If this results in a quit_char being returned to Emacs as
	     input, set Vlast_event_frame properly.  If this doesn't
	     get returned to Emacs as an event, the next event read
	     will set Vlast_event_frame again, so this is safe to do.  */
	  {

    }
  /* Don't insert two BUFFER_SWITCH_EVENT's in a row.
     Just ignore the second one.  */
  else if (event->kind == BUFFER_SWITCH_EVENT
	   && kbd_fetch_ptr != kbd_store_ptr
	   && ((kbd_store_ptr == kbd_buffer
		? kbd_buffer + KBD_BUFFER_SIZE - 1
		: kbd_store_ptr - 1)->kind) == BUFFER_SWITCH_EVENT)
    return;

  if (kbd_store_ptr - kbd_buffer == KBD_BUFFER_SIZE)
    kbd_store_ptr = kbd_buffer;

   overlay, or nil if neither from a string nor from a buffer.  POS is
   the position within OBJECT where the help was found.

   Value is the number of input_events generated.  */

void
gen_help_event (help, frame, window, object, pos)
     Lisp_Object help, frame, object, window;
     int pos;
{
  struct input_event event;

  EVENT_INIT (event);

  event.kind = HELP_EVENT;
  event.frame_or_window = frame;
  event.arg = object;
  event.x = WINDOWP (window) ? window : frame;
  event.y = help;
  event.code = pos;
  kbd_buffer_store_event (&event);
}


/* Store HELP_EVENTs for HELP on FRAME in the input queue.  */

   Except on VMS, all input is read by this function.
   If interrupt_input is nonzero, this function MUST be called
   only when SIGIO is blocked.

   Returns the number of keyboard chars read, or -1 meaning
   this is a bad time to try to read input.  */

static int
read_avail_input (expected)
     int expected;
{

      if (d->read_socket_hook)
        {
          int discard = 0;
          int nr;

          struct input_event hold_quit;

          EVENT_INIT (hold_quit);
          hold_quit.kind = NO_EVENT;

          /* No need for FIONREAD or fcntl; just say don't wait.  */
          while (nr = (*d->read_socket_hook) (d, expected, &hold_quit), nr > 0)
            {
              nread += nr;
              expected = 0;
            }
          
          if (nr == -1)          /* Not OK to read input now. */
            {
              err = 1;
            }
          else if (nr == -2)          /* Non-transient error. */
            {
              /* The display device terminated; it should be closed. */
              
              /* Kill Emacs if this was our last display. */
              if (! display_list->next_display)
                /* Formerly simply reported no input, but that
                   sometimes led to a failure of Emacs to terminate.
                   SIGHUP seems appropriate if we can't reach the
                   terminal.  */
                /* ??? Is it really right to send the signal just to
                   this process rather than to the whole process
                   group?  Perhaps on systems with FIONREAD Emacs is
                   alone in its group.  */
                kill (getpid (), SIGHUP);
              
              /* XXX Is calling delete_display safe here?  It calls Fdelete_frame. */
              if (d->delete_display_hook)
                (*d->delete_display_hook) (d);
              else
                delete_display (d);
            }

          if (hold_quit.kind != NO_EVENT)
            kbd_buffer_store_event (&hold_quit);
        }

      d = next;
    }

   and so this function is called once for each individual termcap
   display.  The first parameter indicates which device to read from.  */

int
tty_read_avail_input (struct display *display,
                      int expected,
                      struct input_event *hold_quit)
{
  /* Using KBD_BUFFER_SIZE - 1 here avoids reading more than
     the kbd_buffer can really hold.  That may prevent loss
     of characters on some systems when input is stuffed at us.  */
  unsigned char cbuf[KBD_BUFFER_SIZE - 1];
  int n_to_read, i;
  struct tty_display_info *tty = display->display_info.tty;
  int nread = 0;

  if (display->type != output_termcap)

#endif /* not MSDOS */
#endif /* not WINDOWSNT */

  for (i = 0; i < nread; i++)
    {
      struct input_event buf;
      EVENT_INIT (buf);
      buf.kind = ASCII_KEYSTROKE_EVENT;
      buf.modifiers = 0;
      if (tty->meta_key == 1 && (cbuf[i] & 0x80))
        buf.modifiers = meta_modifier;
      if (tty->meta_key != 2)
        cbuf[i] &= ~0x80;
      
      buf.code = cbuf[i];
      /* Set the frame corresponding to the active tty.  Note that the
         value of selected_frame is not reliable here, redisplay tends
         to temporarily change it. */
      buf.frame_or_window = tty->top_frame;
      buf.arg = Qnil;
      
      kbd_buffer_store_event (&buf);
      /* Don't look at input that follows a C-g too closely.
         This reduces lossage due to autorepeat on C-g.  */
      if (buf.kind == ASCII_KEYSTROKE_EVENT
          && buf.code == quit_char)
        break;
    }

  return nread;
}
#endif /* not VMS */