Mercurial > emacs

changeset 650:39f0e62a8511

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
*** empty log message ***
author Jim Blandy <jimb@redhat.com>
date Tue, 19 May 1992 05:22:52 +0000
parents 61deba7b73b6
children 144027c7abb2
files lib-src/make-docfile.c lisp/startup.el src/dispnew.c src/keyboard.c src/process.c
diffstat 5 files changed, 122 insertions(+), 86 deletions(-) [+]
line wrap: on
line diff
--- a/lib-src/make-docfile.c	Tue May 19 02:05:47 1992 +0000
+++ b/lib-src/make-docfile.c	Tue May 19 05:22:52 1992 +0000
@@ -170,7 +170,7 @@
       /* Print the C arguments as they would appear in Elisp;
 	 print underscores as hyphens.  */
       if (c == '_')
-	putc ('-');
+	putc ('-', out);
       else
 	putc (c, out);
     }
--- a/lisp/startup.el	Tue May 19 02:05:47 1992 +0000
+++ b/lisp/startup.el	Tue May 19 05:22:52 1992 +0000
@@ -118,7 +118,7 @@
     (if (not (eq system-type 'vax-vms))
 	(mapcar (function
 		 (lambda (var)
-		   (let ((value (getev var)))
+		   (let ((value (getenv var)))
 		     (if (and value
 			      (< (length value) (length default-directory))
 			      (equal (file-attributes default-directory)
--- a/src/dispnew.c	Tue May 19 02:05:47 1992 +0000
+++ b/src/dispnew.c	Tue May 19 05:22:52 1992 +0000
@@ -1780,14 +1780,14 @@
   "Pause, without updating display, for ARG seconds.\n\
 Optional second arg non-nil means ARG is measured in milliseconds.\n\
 \(Not all operating systems support milliseconds.)")
-  (n, millisec)
-     Lisp_Object n, millisec;
+  (arg, millisec)
+     Lisp_Object arg, millisec;
 {
   int usec = 0;
   int sec;
 
-  CHECK_NUMBER (n, 0);
-  sec = XINT (n);
+  CHECK_NUMBER (arg, 0);
+  sec = XINT (arg);
   if (sec <= 0)
     return Qnil;
 
@@ -1801,7 +1801,12 @@
 #endif
     }
 
-  wait_reading_process_input (sec, usec, 0, 0);
+  {
+    Lisp_Object zero;
+
+    XFASTINT (zero) = 0;
+    wait_reading_process_input (sec, usec, zero, 0);
+  }
 
 #if 0 /* No wait_reading_process_input */
   immediate_quit = 1;
@@ -1837,45 +1842,31 @@
   return Qnil;
 }
 
-DEFUN ("sit-for", Fsit_for, Ssit_for, 1, 3, 0,
-  "Perform redisplay, then wait for ARG seconds or until input is available.\n\
-Optional second arg non-nil means ARG counts in milliseconds.\n\
-Optional third arg non-nil means don't redisplay, just wait for input.\n\
-Redisplay is preempted as always if input arrives, and does not happen\n\
-if input is available before it starts.\n\
-Value is t if waited the full time with no input arriving.")
-  (n, millisec, nodisp)
-     Lisp_Object n, millisec, nodisp;
+/* This is just like wait_reading_process_input, except that
+   it does the redisplay.
+
+   It's also just like Fsit_for, except that it can be used for
+   waiting for input as well.  */
+
+Lisp_Object
+sit_for (sec, usec, reading, display)
+     int sec, usec, reading, display;
 {
-  int usec = 0;
-  int sec;
-
-  CHECK_NUMBER (n, 0);
+  Lisp_Object read_kbd;
 
   if (detect_input_pending ())
     return Qnil;
-  
-  if (EQ (nodisp, Qnil))
+
+  if (display)
     redisplay_preserve_echo_area ();
 
-  sec = XINT (n);
-  if (sec <= 0)
-    return Qt;
-
-  if (!NILP (millisec))
-    {
-#ifndef EMACS_HAS_USECS
-      error ("millisecond sleep-for not supported on %s", SYSTEM_TYPE);
-#else
-      usec = sec % 1000 * 1000;
-      sec /= 1000;
-#endif
-    }
-
 #ifdef SIGIO
   gobble_input ();
-#endif				/* SIGIO */
-  wait_reading_process_input (sec, usec, 1, 1);
+#endif
+
+  XSET (read_kbd, Lisp_Int, reading ? -1 : 1);
+  wait_reading_process_input (sec, usec, read_kbd, display);
+
 
 #if 0 /* No wait_reading_process_input available.  */
   immediate_quit = 1;
@@ -1883,7 +1874,7 @@
 
   waitchannels = 1;
 #ifdef VMS
-  input_wait_timeout (XINT (n));
+  input_wait_timeout (XINT (arg));
 #else				/* not VMS */
 #ifndef HAVE_TIMEVAL
   timeout_sec = sec;
@@ -1901,18 +1892,54 @@
   return detect_input_pending () ? Qnil : Qt;
 }
 
+DEFUN ("sit-for", Fsit_for, Ssit_for, 1, 3, 0,
+  "Perform redisplay, then wait for ARG seconds or until input is available.\n\
+Optional second arg non-nil means ARG counts in milliseconds.\n\
+Optional third arg non-nil means don't redisplay, just wait for input.\n\
+Redisplay is preempted as always if input arrives, and does not happen\n\
+if input is available before it starts.\n\
+Value is t if waited the full time with no input arriving.")
+  (arg, millisec, nodisp)
+     Lisp_Object arg, millisec, nodisp;
+{
+  int usec = 0;
+  int sec = 0;
+
+  CHECK_NUMBER (arg, 0);
+
+  sec = XINT (arg);
+  if (sec <= 0)
+    return Qt;
+
+  if (!NILP (millisec))
+    {
+#ifndef EMACS_HAS_USECS
+      error ("millisecond sit-for not supported on %s", SYSTEM_TYPE);
+#else
+      usec = (sec % 1000) * 1000;
+      sec /= 1000;
+#endif
+    }
+
+  return sit_for (sec, usec, 0, NILP (nodisp));
+}
+
 DEFUN ("sleep-for-millisecs", Fsleep_for_millisecs, Ssleep_for_millisecs,
   1, 1, 0,
   "Pause, without updating display, for ARG milliseconds.")
-  (n)
-     Lisp_Object n;
+  (arg)
+     Lisp_Object arg;
 {
+  Lisp_Object zero;
+
 #ifndef EMACS_HAS_USECS
   error ("sleep-for-millisecs not supported on %s", SYSTEM_TYPE);
 #else
-  CHECK_NUMBER (n, 0);
-  wait_reading_process_input (XINT (n) / 1000, XINT (n) % 1000 * 1000,
-			      0, 0);
+  CHECK_NUMBER (arg, 0);
+
+  XFASTINT (zero) = 0;
+  wait_reading_process_input (XINT (arg) / 1000, XINT (arg) % 1000 * 1000,
+			      zero, 0);
   return Qnil;
 #endif /* EMACS_HAS_USECS */
 }
--- a/src/keyboard.c	Tue May 19 02:05:47 1992 +0000
+++ b/src/keyboard.c	Tue May 19 05:22:52 1992 +0000
@@ -1148,7 +1148,7 @@
     }
 
   /* Save outer setjmp data, in case called recursively.  */
-  bcopy (getcjmp, save_jump, sizeof getcjmp);
+  save_getcjmp (save_jump);
 
   stop_polling ();
 
@@ -1162,8 +1162,6 @@
       XSET (Vlast_event_screen, Lisp_Screen, selected_screen);
 #endif
 
-      clear_waiting_for_input ();
-
       goto non_reread;
     }
 
@@ -1182,7 +1180,7 @@
     {
       Lisp_Object tem0;
 
-      tem0 = Fsit_for (make_number (echo_keystrokes), Qnil, Qt);
+      tem0 = sit_for (echo_keystrokes, 0, 1, 1);
       if (EQ (tem0, Qt))
 	echo ();
     }
@@ -1223,7 +1221,7 @@
       {
 	Lisp_Object tem0;
 	int delay = delay_level * XFASTINT (Vauto_save_timeout) / 4;
-	tem0 = Fsit_for (make_number (delay), Qnil, Qt);
+	tem0 = sit_for (delay, 0, 1, 1);
 	if (EQ (tem0, Qt))
 	  {
 	    jmp_buf temp;
@@ -1263,7 +1261,7 @@
 
  non_reread:
 
-  bcopy (save_jump, getcjmp, sizeof getcjmp);
+  restore_getcjmp (save_jump);
 
   start_polling ();
 
@@ -1590,7 +1588,10 @@
 #endif /* SIGIO */
       if (EVENT_QUEUES_EMPTY)
 	{
-	  wait_reading_process_input (0, 0, -1, 1);
+	  Lisp_Object minus_one;
+
+	  XSET (minus_one, Lisp_Int, -1);
+	  wait_reading_process_input (0, 0, minus_one, 1);
 
 	  if (!interrupt_input && EVENT_QUEUES_EMPTY)
 	    {
@@ -3330,7 +3331,7 @@
   quit_error_check ();
   sigfree ();
   /* Prevent another signal from doing this before we finish.  */
-  waiting_for_input = 0;
+  clear_waiting_for_input ();
   input_pending = 0;
 
 #if 0
--- a/src/process.c	Tue May 19 02:05:47 1992 +0000
+++ b/src/process.c	Tue May 19 05:22:52 1992 +0000
@@ -1587,10 +1587,11 @@
 	seconds = 0;
     }
 
+  if (NILP (proc))
+    XFASTINT (proc) = 0;
+
   return
-    (wait_reading_process_input (seconds, useconds,
-				 (NILP (proc)
-				  ? XPROCESS (get_process (proc)) : 0), 0)
+    (wait_reading_process_input (seconds, useconds, proc, 0)
      ? Qt : Qnil);
 }
 
@@ -1610,14 +1611,14 @@
      zero for no limit, or
      -1 means gobble data immediately available but don't wait for any.
 
-   read_kbd is:
+   read_kbd is a lisp value:
      0 to ignore keyboard input, or
      1 to return when input is available, or
      -1 means caller will actually read the input, so don't throw to
        the quit handler, or
-     a pointer to a struct Lisp_Process, meaning wait until something
-       arrives from that process.  The return value is true iff we read
-       some input from that process.
+     a process object, meaning wait until something arrives from that
+       process.  The return value is true iff we read some input from
+       that process.
 
    do_display != 0 means redisplay should be done to show subprocess
    output that arrives.
@@ -1628,7 +1629,9 @@
    Otherwise, return true iff we recieved input from any process.  */
 
 wait_reading_process_input (time_limit, microsecs, read_kbd, do_display)
-     int time_limit, microsecs, read_kbd, do_display;
+     int time_limit, microsecs;
+     Lisp_Object read_kbd;
+     int do_display;
 {
   register int channel, nfds, m;
   static SELECT_TYPE Available;
@@ -1642,15 +1645,16 @@
 
   FD_ZERO (&Available);
 
-  /* Detect when read_kbd is really the address of a Lisp_Process.  */
-  if (read_kbd > 10 || read_kbd < -1)
+  /* If read_kbd is a process to watch, set wait_proc and wait_channel
+     accordingly.  */
+  if (XTYPE (read_kbd) == Lisp_Process)
     {
-      wait_proc = (struct Lisp_Process *) read_kbd;
+      wait_proc = XPROCESS (read_kbd);
       wait_channel = XFASTINT (wait_proc->infd);
-      read_kbd = 0;
+      XFASTINT (read_kbd) = 0;
     }
 
-  waiting_for_user_input_p = read_kbd;
+  waiting_for_user_input_p = XINT (read_kbd);
 
   /* Since we may need to wait several times,
      compute the absolute time to return at.  */
@@ -1666,7 +1670,7 @@
       /* If calling from keyboard input, do not quit
 	 since we want to return C-g as an input character.
 	 Otherwise, do pending quit if requested.  */
-      if (read_kbd >= 0)
+      if (XINT (read_kbd) >= 0)
 	QUIT;
 
       /* If status of something has changed, and no input is available,
@@ -1710,13 +1714,13 @@
 
       /* Cause C-g and alarm signals to take immediate action,
 	 and cause input available signals to zero out timeout */
-      if (read_kbd < 0)
+      if (XINT (read_kbd) < 0)
 	set_waiting_for_input (&timeout);
 
       /* Wait till there is something to do */
 
       Available = input_wait_mask;
-      if (!read_kbd)
+      if (! XINT (read_kbd))
 	FD_CLR (0, &Available);
 
       /* If screen size has changed or the window is newly mapped,
@@ -1726,7 +1730,7 @@
       if (screen_garbaged)
 	redisplay_preserve_echo_area ();
 
-      if (read_kbd && detect_input_pending ())
+      if (XINT (read_kbd) && detect_input_pending ())
 	nfds = 0;
       else
 	nfds = select (MAXDESC, &Available, 0, 0, &timeout);
@@ -1779,7 +1783,7 @@
       /* If there is any, return immediately
 	 to give it higher priority than subprocesses */
 
-      if (read_kbd && detect_input_pending ())
+      if (XINT (read_kbd) && detect_input_pending ())
 	break;
 
 #ifdef SIGIO
@@ -1789,9 +1793,9 @@
 	 but select says there is input.  */
 
       /*
-	if (read_kbd && interrupt_input && (Available & fileno (stdin)))
+	if (XINT (read_kbd) && interrupt_input && (Available & fileno (stdin)))
 	*/
-      if (read_kbd && interrupt_input && (FD_ISSET (fileno (stdin), &Available)))
+      if (XINT (read_kbd) && interrupt_input && (FD_ISSET (fileno (stdin), &Available)))
 	kill (0, SIGIO);
 #endif
 
@@ -1810,7 +1814,7 @@
 
       /* If checking input just got us a size-change event from X,
 	 obey it now if we should.  */
-      if (read_kbd)
+      if (XINT (read_kbd))
 	do_pending_window_change ();
 
       /* Check for data from a process or a command channel */
@@ -1921,7 +1925,7 @@
   /* If calling from keyboard input, do not quit
      since we want to return C-g as an input character.
      Otherwise, do pending quit if requested.  */
-  if (read_kbd >= 0)
+  if (XINT (read_kbd) >= 0)
     {
       /* Prevent input_pending from remaining set if we quit.  */
       clear_input_pending ();
@@ -2134,7 +2138,12 @@
 	/* Allow input from processes between bursts of sending.
 	   Otherwise things may get stopped up.  */
 	if (len > 0)
-	  wait_reading_process_input (-1, 0, 0, 0);
+	  {
+	    Lisp_Object zero;
+
+	    XFASTINT (zero) = 0;
+	    wait_reading_process_input (-1, 0, zero, 0);
+	  }
       }
 #endif
   else
@@ -2901,7 +2910,7 @@
      zero for no limit, or
      -1 means gobble data immediately available but don't wait for any.
 
-   read_kbd is:
+   read_kbd is a Lisp_Object:
      0 to ignore keyboard input, or
      1 to return when input is available, or
      -1 means caller will actually read the input, so don't throw to
@@ -2912,14 +2921,13 @@
    do_display != 0 means redisplay should be done to show subprocess
    output that arrives.  This version of the function ignores it.
 
-   If read_kbd is a pointer to a struct Lisp_Process, then the
-     function returns true iff we received input from that process
-     before the timeout elapsed.
-   Otherwise, return true iff we recieved input from any process.  */
+   Return true iff we recieved input from any process.  */
 
 int
 wait_reading_process_input (time_limit, microsecs, read_kbd, do_display)
-     int time_limit, microsecs, read_kbd, do_display;
+     int time_limit, microsecs;
+     Lisp_Object read_kbd;
+     int do_display;
 {
   EMACS_TIME end_time, timeout, *timeout_p;
   int waitchannels;
@@ -2952,12 +2960,12 @@
     {
       int nfds;
 
-      waitchannels = read_kbd ? 1 : 0;
+      waitchannels = XINT (read_kbd) ? 1 : 0;
 
       /* If calling from keyboard input, do not quit
 	 since we want to return C-g as an input character.
 	 Otherwise, do pending quit if requested.  */
-      if (read_kbd >= 0)
+      if (XINT (read_kbd) >= 0)
 	QUIT;
 
       if (timeout_p)
@@ -2970,7 +2978,7 @@
 
       /* Cause C-g and alarm signals to take immediate action,
 	 and cause input available signals to zero out timeout.  */
-      if (read_kbd < 0)
+      if (XINT (read_kbd) < 0)
 	set_waiting_for_input (&timeout);
 
       /* If a screen has been newly mapped and needs updating,
@@ -2978,7 +2986,7 @@
       if (screen_garbaged)
 	redisplay_preserve_echo_area ();
 
-      if (read_kbd && detect_input_pending ())
+      if (XINT (read_kbd) && detect_input_pending ())
 	nfds = 0;
       else
 	nfds = select (1, &waitchannels, 0, 0, timeout_p);
@@ -3001,7 +3009,7 @@
 	/* System sometimes fails to deliver SIGIO.  */
 	kill (getpid (), SIGIO);
 #endif
-      if (read_kbd && interrupt_input && (waitchannels & 1))
+      if (XINT (read_kbd) && interrupt_input && (waitchannels & 1))
 	kill (0, SIGIO);
 
       /* If we have timed out (nfds == 0) or found some input (nfds > 0),