entered into RCS

10 files changed, 276 insertions, 197 deletions

diff --git a/lib-src/b2m.c b/lib-src/b2m.c
index 2aa79b8edc0..5ae81949aed 100644
--- a/lib-src/b2m.c
+++ b/lib-src/b2m.c
@@ -17,7 +17,14 @@
 
 #include <stdio.h>
 #include <time.h>
+
+#include "../src/config.h"
+
+#ifdef USG
+#include <string.h>
+#else
 #include <strings.h>
+#endif
 
 /* BSD's strings.h does not declare the type of strtok.  */
 extern char *strtok ();
diff --git a/lib-src/timer.c b/lib-src/timer.c
index 2c1b9a729f6..a12295db014 100644
--- a/lib-src/timer.c
+++ b/lib-src/timer.c
@@ -1,17 +1,17 @@
-/*
- * timer.c --- daemon to provide a tagged interval timer service
- *
- * This little daemon runs forever waiting for signals.  SIGIO (or SIGUSR1)
- * causes it to read an event spec from stdin; that is, a date followed by
- * colon followed by an event label.  SIGALRM causes it to check its queue
- * for events attached to the current second; if one is found, its label
- * is written to stdout.  SIGTERM causes it to terminate, printing a list
- * of pending events.
- *
- * This program is intended to be used with the lisp package called timer.el.
- * It was written anonymously in 1990.  This version was documented and
- * rewritten for portability by esr@snark,thyrsus.com, Aug 7 1992. 
- */
+/* timer.c --- daemon to provide a tagged interval timer service
+
+   This little daemon runs forever waiting for signals.  SIGIO (or
+   SIGUSR1) causes it to read an event spec from stdin; that is, a
+   date followed by colon followed by an event label.  SIGALRM causes
+   it to check its queue for events attached to the current second; if
+   one is found, its label is written to stdout.  SIGTERM causes it to
+   terminate, printing a list of pending events.
+
+   This program is intended to be used with the lisp package called
+   timer.el.  It was written anonymously in 1990.  This version was
+   documented and rewritten for portability by esr@snark,thyrsus.com,
+   Aug 7 1992.  */
+
 #include <stdio.h>
 #include <signal.h>
 #include <fcntl.h>      /* FASYNC */
@@ -24,10 +24,8 @@
 #endif
 
 extern int errno;
-extern char *sys_errlist[], *malloc();
-extern time_t time();
-
-#define MAXEVENTS 256
+extern char *sys_errlist[], *malloc ();
+extern time_t time ();
 
 /*
  * The field separator for input.  This character shouldn't be legal in a date,
@@ -37,185 +35,235 @@ extern time_t time();
 #define FS '@'
 
 struct event
-{
+  {
     char *token;
     time_t reply_at;
-}
-events[MAXEVENTS];
+  };
+int events_size;                /* How many slots have we allocated?  */
+int num_events;                 /* How many are actually scheduled?  */
+struct event *events;           /* events[0 .. num_events-1] are the
+                                   valid events.  */
 
 char *pname;      /* programme name for error messages */
 
 /* Accepts a string of two fields seperated by FS.
- * First field is string for getdate, saying when to wake-up.
- * Second field is a token to identify the request.
- */
-void schedule(str)
-        char *str;
+   First field is string for getdate, saying when to wake-up.
+   Second field is a token to identify the request.  */
+void
+schedule (str)
+     char *str;
 {
-    extern time_t getdate();
-    extern char *strcpy();
-    time_t now;
-    register char *p;
-    static struct event *ep;
-
-#ifdef DEBUG
-    (void) fprintf(stderr, "Timer sees: %s", str);
-#endif /* DEBUG */
-
-    /* check entry format */
-    for(p = str; *p && *p != FS; p++)
-        continue;
-    if (!*p)
+  extern time_t getdate ();
+  extern char *strcpy ();
+  time_t now;
+  register char *p;
+  static struct event *ep;
+
+  /* check entry format */
+  for (p = str; *p && *p != FS; p++)
+    continue;
+  if (!*p)
     {
-        (void)fprintf(stderr, "%s: bad input format: %s", pname, str);
-        return;
+      fprintf (stderr, "%s: bad input format: %s", pname, str);
+      return;
     }
-    *p++ = 0;
+  *p++ = 0;
   
-    /* allocate an event slot */
-    for(ep = events; ep < events + MAXEVENTS; ep++)
-        if (ep->token == (char *)NULL)
-            break;
-    if (ep == events + MAXEVENTS)
-        (void) fprintf(stderr, "%s: too many events: %s", pname, str);
-
-    /* don't allow users to schedule events in past time */
-    else if ((ep->reply_at = get_date(str, NULL)) - time(&now) < 0)
-        (void)fprintf(stderr, "%s: bad time spec: %s%c%s", pname, str, FS, p);
-
-    /* save the event description */
-    else if ((ep->token = malloc((unsigned)strlen(p) + 1)) == NULL)
-        (void)fprintf(stderr, "%s: malloc %s: %s%c%s",
-                      pname, sys_errlist[errno], str, FS, p);
-    else
+  /* allocate an event slot */
+  ep = events + num_events;
+
+  /* If the event array is full, stretch it.  After stretching, we know
+     that ep will be pointing to an available event spot.  */
+  if (ep == events + events_size)
     {
-        (void)strcpy(ep->token, p);
+      int old_size = events_size;
 
-#ifdef DEBUG
-        (void) fprintf(stderr,
-                       "New event: %ld: %s", ep->reply_at, ep->token);
-#endif /* DEBUG */
+      events_size *= 2;
+      events = ((struct event *)
+                realloc (events, events_size * sizeof (struct event)));
+      if (! events)
+        {
+          fprintf (stderr, "%s: virtual memory exhausted.\n", pname);
+
+          /* Should timer exit now?  Well, we've still got other
+             events in the queue, and more memory might become
+             available in the future, so we'll just toss this event.
+             This will screw up whoever scheduled the event, but
+             maybe someone else will survive.  */
+          return;
+        }
+
+      while (old_size < events_size)
+        events[old_size++].token = NULL;
+    }
+
+  /* Don't allow users to schedule events in past time.  */
+  ep->reply_at = get_date (str, NULL);
+  if (ep->reply_at - time (&now) < 0)
+    {
+      fprintf (stderr, "%s: bad time spec: %s%c%s", pname, str, FS, p);
+      return;
+    }
+
+  /* save the event description */
+  ep->token = (char *) malloc ((unsigned) strlen (p) + 1);
+  if (! ep->token)
+    {
+      fprintf (stderr, "%s: malloc %s: %s%c%s",
+               pname, sys_errlist[errno], str, FS, p);
+      return;
     }
+
+  strcpy (ep->token, p);
+  num_events++;
 }
 
 void
-notify()
+notify ()
 {
-    time_t now, tdiff, waitfor = -1;
-    register struct event *ep;
+  time_t now, tdiff, waitfor;
+  register struct event *ep;
+
+  now = time ((time_t *) NULL);
 
-    now = time((time_t *)NULL);
+  for (ep = events; ep < events + num_events; ep++)
+    /* Are any events ready to fire?  */
+    if (ep->reply_at <= now)
+      {
+        fputs (ep->token, stdout);
+        free (ep->token);
 
-    for(ep = events; ep < events + MAXEVENTS; ep++)
-        if (ep->token)
+        /* We now have a hole in the event array; fill it with the last
+           event.  */
+        ep->token = events[num_events].token;
+        ep->reply_at = events[num_events].reply_at;
+        num_events--;
+
+        /* We ought to scan this event again.  */
+        ep--;
+      }
+    else
+      {
+        /* next timeout should be the soonest of any remaining */
+        if ((tdiff = ep->reply_at - now) < waitfor || waitfor < 0)
+          waitfor = (long)tdiff;
+      }
+
+  /* If there are no more events, we needn't bother setting an alarm.  */
+  if (num_events > 0)
+    alarm (waitfor);
+}
+
+void
+getevent ()
+{
+  int i;
+  char *buf;
+  int buf_size;
+
+  /* In principle the itimer should be disabled on entry to this
+     function, but it really doesn't make any important difference
+     if it isn't.  */
+
+  buf_size = 80;
+  buf = (char *) malloc (buf_size);
+
+  /* Read a line from standard input, expanding buf if it is too short
+     to hold the line.  */
+  for (i = 0; ; i++)
+    {
+      int c;
+
+      if (i >= buf_size)
         {
-            /* any events ready to fire? */
-            if (ep->reply_at <= now)
-            {
-#ifdef DEBUG
-                (void) fprintf(stderr,
-                               "Event %d firing: %ld @ %s",
-                               (ep - events), ep->reply_at, ep->token);
-#endif /* DEBUG */
-                (void)fputs(ep->token, stdout);
-                free(ep->token);
-                ep->token = (char *)NULL;
-            }
-            else
+          buf_size *= 2;
+          buf = (char *) realloc (buf, buf_size);
+
+          /* If we're out of memory, toss this event.  */
+          do
             {
-#ifdef DEBUG
-                (void) fprintf(stderr,
-                           "Event %d still waiting: %ld @ %s",
-                           (ep - events), ep->reply_at, ep->token);
-#endif /* DEBUG */
-
-                /* next timeout should be the soonest of any remaining */
-                if ((tdiff = ep->reply_at - now) < waitfor || waitfor < 0)
-                    waitfor = (long)tdiff;
+              c = getchar ();
             }
+          while (c != '\n' && c != EOF);
+          
+          return;
         }
 
-    /* If there's no more events, SIGIO should be next wake-up */
-    if (waitfor != -1)
-    {
-#ifdef DEBUG
-        (void) fprintf(stderr,
-                       "Setting %d-second alarm\n", waitfor);
-#endif /* DEBUG */
-        (void)alarm(waitfor);
-    }
-}
+      c = getchar ();
 
-void
-getevent()
-{
-    extern char *fgets();
-    struct event *ep;
-    char buf[BUFSIZ];
+      if (c == EOF)
+        exit (0);
 
-    /* in principle the itimer should be disabled on entry to this function,
-       but it really doesn't make any important difference if it isn't */
+      if (c == '\n')
+        {
+          buf[i] = '\0';
+          break;
+        }
 
-    if (fgets(buf, sizeof(buf), stdin) == NULL)
-        exit(0);
+      buf[i] = c;
+    }
 
-    /* register the event */
-    schedule(buf);
+  /* Register the event.  */
+  schedule (buf);
+  free (buf);
 
-    /* Who knows what this interrupted, or if it said "now"? */
-    notify();
+  /* Who knows what this interrupted, or if it said "now"? */
+  notify ();
 }
 
 void
-sigcatch(sig)
+sigcatch (sig)
+     int sig;
 /* dispatch on incoming signal, then restore it */
 {
-    struct event *ep;
+  struct event *ep;
 
-    switch(sig)
+  switch (sig)
     {
     case SIGALRM:
-#ifdef DEBUG
-        (void) fprintf(stderr, "Alarm signal received\n");
-#endif /* DEBUG */
-        notify();
-        break;
+      notify ();
+      break;
     case SIGIO:
-        getevent();
-        break;
+      getevent ();
+      break;
     case SIGTERM:
-        (void) fprintf(stderr, "Events still queued:\n");
-        for (ep = events; ep < events + MAXEVENTS; ep++)
-            if (ep->token)
-                (void) fprintf(stderr, "%d = %ld @ %s",
-                               ep - events, ep->reply_at, ep->token);
-        exit(0);
-        break;
+      fprintf (stderr, "Events still queued:\n");
+      for (ep = events; ep < events + num_events; ep++)
+        fprintf (stderr, "%d = %ld @ %s",
+                 ep - events, ep->reply_at, ep->token);
+      exit (0);
+      break;
     }
 
-    /* required on older UNIXes; harmless on newer ones */
-    (void) signal(sig, sigcatch);
+  /* required on older UNIXes; harmless on newer ones */
+  signal (sig, sigcatch);
 }
 
 /*ARGSUSED*/
 int
-main(argc, argv)
+main (argc, argv)
      int argc;
      char **argv;
 {
-  for (pname = argv[0] + strlen(argv[0]); *pname != '/' && pname != argv[0];
+  for (pname = argv[0] + strlen (argv[0]);
+       *pname != '/' && pname != argv[0];
        pname--);
-  if (*pname == '/') pname++;
+  if (*pname == '/')
+    pname++;
+
+  events_size = 16;
+  events = ((struct event *) malloc (events_size * sizeof (*events)));
+  num_events = 0;
 
-  (void)signal(SIGIO, sigcatch);
-  (void)signal(SIGALRM, sigcatch);
-  (void)signal(SIGTERM, sigcatch);
+  signal (SIGIO, sigcatch);
+  signal (SIGALRM, sigcatch);
+  signal (SIGTERM, sigcatch);
 
 #ifndef USG
-  (void)fcntl(0, F_SETFL, FASYNC);
+  fcntl (0, F_SETFL, FASYNC);
 #endif /* USG */
 
-  while (1) pause();
+  while (1) pause ();
 }
 
 /* timer.c ends here */
diff --git a/lisp/calendar/solar.el b/lisp/calendar/solar.el
index 6a6956ad81d..84b9dfe6ffb 100644
--- a/lisp/calendar/solar.el
+++ b/lisp/calendar/solar.el
@@ -328,40 +328,40 @@ latitude, time zone, and date.
 
 This function is suitable for execution in a .emacs file."
  (interactive "p")
- (if (< arg 16)
-     (if (not (and calendar-latitude calendar-longitude calendar-time-zone))
-         (solar-setup)))
+ (if (and (< arg 16)
+          (not (and calendar-latitude calendar-longitude calendar-time-zone)))
+     (solar-setup))
  (let* ((calendar-longitude
-         (if (< arg 16)
-             calendar-longitude
+         (if (< arg 16) calendar-longitude
            (solar-get-number
             "Enter longitude (decimal fraction; + east, - west): ")))
         (calendar-latitude
-         (if (< arg 16)
-             calendar-latitude
+         (if (< arg 16) calendar-latitude
            (solar-get-number
             "Enter latitude (decimal fraction; + north, - south): ")))
         (calendar-time-zone
-         (if (< arg 16)
-             calendar-time-zone
+         (if (< arg 16) calendar-time-zone
            (solar-get-number
             "Enter difference from Universal Time (in minutes): ")))
         (calendar-location-name
-         (let ((float-output-format "%.1f"))
-           (format "%s%s, %s%s"
-                   (abs calendar-latitude)
-                   (if (> calendar-latitude 0) "N" "S")
-                   (abs calendar-longitude)
-                   (if (> calendar-longitude 0) "E" "W"))))
+         (if (< arg 16) calendar-location-name
+           (let ((float-output-format "%.1f"))
+             (format "%s%s, %s%s"
+                     (abs calendar-latitude)
+                     (if (> calendar-latitude 0) "N" "S")
+                     (abs calendar-longitude)
+                     (if (> calendar-longitude 0) "E" "W")))))
         (calendar-standard-time-zone-name
-         (cond ((= calendar-time-zone 0) "UT")
-               ((< calendar-time-zone 0) (format "UT%dmin" calendar-time-zone))
-               (t                   (format "UT+%dmin" calendar-time-zone))))
-        (calendar-daylight-savings-starts nil)
-        (calendar-daylight-savings-ends nil)
-        (date (if (< arg 4)
-                  (calendar-current-date)
-                (calendar-read-date)))
+         (if (< arg 16) calendar-standard-time-zone-name
+           (cond ((= calendar-time-zone 0) "UT")
+                 ((< calendar-time-zone 0)
+                     (format "UT%dmin" calendar-time-zone))
+                 (t  (format "UT+%dmin" calendar-time-zone)))))
+        (calendar-daylight-savings-starts
+         (if (< arg 16) calendar-daylight-savings-starts))
+        (calendar-daylight-savings-ends
+         (if (< arg 16) calendar-daylight-savings-ends))
+        (date (if (< arg 4) (calendar-current-date) (calendar-read-date)))
         (date-string (calendar-date-string date t))
         (time-string (solar-sunrise-sunset date))
         (msg (format "%s: %s" date-string time-string))
diff --git a/lisp/info.el b/lisp/info.el
index a044aa77796..bf6dec805ea 100644
--- a/lisp/info.el
+++ b/lisp/info.el
@@ -179,7 +179,7 @@ to read a file name from the minibuffer."
                             (insert-buffer-substring buf)
                             (set-marker Info-tag-table-marker
                                         (match-end 0))))
-                     (set-marker Info-tag-table-marker pos))))
+                      (set-marker Info-tag-table-marker pos))))
               (setq Info-current-file
                     (file-name-sans-versions buffer-file-name))))
         (if (equal nodename "*")
diff --git a/lisp/progmodes/hideif.el b/lisp/progmodes/hideif.el
index 16178c018e2..5e6f9adbd5f 100644
--- a/lisp/progmodes/hideif.el
+++ b/lisp/progmodes/hideif.el
@@ -198,6 +198,7 @@ before `hide-ifdef-mode' modifies it.")
           (cons '(hide-ifdef-mode " Ifdef")
                 minor-mode-alist)))
 
+;;;###autoload
 (defun hide-ifdef-mode (arg)
   "Toggle Hide-Ifdef mode.  This is a minor mode, albeit a large one.
 With ARG, turn Hide-Ifdef mode on iff arg is positive.
@@ -845,6 +846,7 @@ to redo on a recursive entry."
 
 ;===%%SF%% exports (Start)  ===
 
+;;;###autoload
 (defvar hide-ifdef-initially nil
   "*Non-nil if `hide-ifdefs' should be called when Hide-Ifdef mode
 is first activated.")
@@ -852,12 +854,14 @@ is first activated.")
 (defvar hide-ifdef-hiding nil
   "Non-nil if text might be hidden.")
 
+;;;###autoload
 (defvar hide-ifdef-read-only nil
   "*Set to non-nil if you want buffer to be read-only while hiding text.")
 
 (defvar hif-outside-read-only nil
   "Internal variable.  Saves the value of `buffer-read-only' while hiding.")
 
+;;;###autoload
 (defvar hide-ifdef-lines nil
   "*Set to t if you don't want to see the #ifX, #else, and #endif lines.")
 
diff --git a/lisp/sort.el b/lisp/sort.el
index dd238d326e5..4405b6e77c0 100644
--- a/lisp/sort.el
+++ b/lisp/sort.el
@@ -29,9 +29,10 @@
 Arguments are REVERSE NEXTRECFUN ENDRECFUN &optional STARTKEYFUN ENDKEYFUN.
 
 We divide the accessible portion of the buffer into disjoint pieces
-called sort records.  A portion of each sort record (perhaps all of it)
-is designated as the sort key.  The records are rearranged in the buffer
-in order by their sort keys.  The records may or may not be contiguous.
+called sort records.  A portion of each sort record (perhaps all of
+it) is designated as the sort key.  The records are rearranged in the
+buffer in order by their sort keys.  The records may or may not be
+contiguous.
 
 Usually the records are rearranged in order of ascending sort key.
 If REVERSE is non-nil, they are rearranged in order of descending sort key.
@@ -78,19 +79,19 @@ same as ENDRECFUN."
                                     'buffer-substring-lessp)
                                    (t
                                     'string<)))
-                    (sort sort-lists
-                          (cond ((numberp (car (car sort-lists)))
-                                 (function
-                                  (lambda (a b)
-                                    (< (car a) (car b)))))
-                                ((consp (car (car sort-lists)))
-                                 (function
-                                  (lambda (a b)
-                                    (buffer-substring-lessp (car a) (car b)))))
-                                (t
-                                 (function
-                                  (lambda (a b)
-                                    (string< (car a) (car b)))))))))
+                  (sort sort-lists
+                        (cond ((numberp (car (car sort-lists)))
+                               (function
+                                (lambda (a b)
+                                  (< (car a) (car b)))))
+                              ((consp (car (car sort-lists)))
+                               (function
+                                (lambda (a b)
+                                  (buffer-substring-lessp (car a) (car b)))))
+                              (t
+                               (function
+                                (lambda (a b)
+                                  (string< (car a) (car b)))))))))
           (if reverse (setq sort-lists (nreverse sort-lists)))
           (if messages (message "Reordering buffer..."))
           (sort-reorder-buffer sort-lists old)))
diff --git a/lisp/timer.el b/lisp/timer.el
index 128d32c7d30..bbd0db72742 100644
--- a/lisp/timer.el
+++ b/lisp/timer.el
@@ -50,7 +50,7 @@ the call to the function."
          (continue-process timer-process)))
   ;; There should be a living, breathing timer process now
   (let ((token (concat (current-time-string) "-" (length timer-alist))))
-    (send-string timer-process (concat time "\001" token "\n"))
+    (send-string timer-process (concat time "@" token "\n"))
     (setq timer-alist (cons (list token repeat function args) timer-alist))))
 
 (defun timer-process-filter (proc str)
@@ -63,9 +63,9 @@ the call to the function."
       (cond
        (do (apply (nth 2 do) (nth 3 do))   ; do it
            (if (natnump (nth 1 do))        ; reschedule it
-               (send-string proc (concat (nth 1 do) " sec\001" (car do) "\n"))
+               (send-string proc (concat (nth 1 do) " sec@" (car do) "\n"))
              (setq timer-alist (delq do timer-alist))))
-       ((string-match "timer: \\([^:]+\\): \\([^\001]*\\)\001\\(.*\\)$" token)
+       ((string-match "timer: \\([^:]+\\): \\([^@]*\\)@\\(.*\\)$" token)
         (setq error (substring token (match-beginning 1) (match-end 1))
               do    (substring token (match-beginning 2) (match-end 2))
               token (assoc (substring token (match-beginning 3) (match-end 3))
diff --git a/src/buffer.h b/src/buffer.h
index a75d81bfd4a..a0e06025893 100644
--- a/src/buffer.h
+++ b/src/buffer.h
@@ -1,11 +1,11 @@
 /* Header file for the buffer manipulation primitives.
-   Copyright (C) 1985, 1986, 1990 Free Software Foundation, Inc.
+   Copyright (C) 1985, 1986, 1990, 1992 Free Software Foundation, Inc.
 
 This file is part of GNU Emacs.
 
 GNU Emacs is free software; you can redistribute it and/or modify
 it under the terms of the GNU General Public License as published by
-the Free Software Foundation; either version 1, or (at your option)
+the Free Software Foundation; either version 2, or (at your option)
 any later version.
 
 GNU Emacs is distributed in the hope that it will be useful,
@@ -296,6 +296,15 @@ extern struct buffer buffer_local_flags;
 
 extern struct buffer buffer_local_symbols;
 
+/* This structure holds the required types for the values in the
+   buffer-local slots.  If a slot contains Qnil, then the
+   corresponding buffer slot may contain a value of any type.  If a
+   slot contains an integer, then prospective values' tags must be
+   equal to that integer.  When a tag does not match, the function
+   buffer_slot_type_mismatch will signal an error.  The value Qnil may
+   always be safely stored in any slot.  */
+struct buffer buffer_local_types;
+
 /* Point in the current buffer. */
 
 #define point (current_buffer->text.pt + 0)
diff --git a/src/frame.h b/src/frame.h
index 8b46e591a20..1a87e6c618d 100644
--- a/src/frame.h
+++ b/src/frame.h
@@ -73,7 +73,7 @@ struct frame
   /* New height and width for pending size change.  0 if no change pending.  */
   int new_height, new_width;
 
-  /* Name of this frame: a Lisp string.  */
+  /* Name of this frame: a Lisp string.  See also `explicit_name'.  */
   Lisp_Object name;
 
   /* The frame which should recieve keystrokes that occur in this
@@ -143,6 +143,12 @@ struct frame
   /* True if frame's root window can't be split.  */
   char no_split;
 
+  /* If this is set, then Emacs won't change the frame name to indicate
+     the current buffer, etcetera.  If the user explicitly sets the frame
+     name, this gets set.  If the user sets the name to Qnil, this is
+     cleared.  */
+  char explicit_name;
+
   /* Storage for messages to this frame. */
   char *message_buf;
 
@@ -285,8 +291,8 @@ extern int message_buf_print;
 #define FRAME_NO_SPLIT_P(f) 0
 #define FRAME_WANTS_MODELINE_P(f) 1
 #define FRAME_ICONIFIED_P(f) 0
-#define FRAME_MINIBUF_WINDOW(f) (minibuf_window)
-#define FRAME_ROOT_WINDOW(f) (XWINDOW (minibuf_window)->prev)
+#define FRAME_MINIBUF_WINDOW(f) (the_only_frame.root_window)
+#define FRAME_ROOT_WINDOW(f) (the_only_frame.root_window)
 #define FRAME_SELECTED_WINDOW(f) (selected_window)
 #define SET_GLYPHS_FRAME(glyphs,frame) do ; while (0)
 #define FRAME_INSERT_COST(frame)  (the_only_frame.insert_line_cost)
diff --git a/src/window.h b/src/window.h
index 8cb36ef0a8d..aa4278623ca 100644
--- a/src/window.h
+++ b/src/window.h
@@ -63,11 +63,12 @@ initially the root window is a leaf window, but if more windows
 are created then that leaf window ceases to be root and a newly
 made combination window becomes root instead.
 
-In any case, prev of the minibuf window is the root window and
-next of the root window is the minibuf window.  To find the
-root window at any time, do XWINDOW (minibuf_window)->prev.
+In any case, on screens which have an ordinary window and a
+minibuffer, prev of the minibuf window is the root window and next of
+the root window is the minibuf window.  On minibufferless screens or
+minibuffer-only screens, the root window and the minibuffer window are
+one and the same, so its prev and next members are nil.  */
 
-*/
 
 struct window
   {
@@ -174,8 +175,7 @@ extern int window_select_count;
 
 /* The minibuffer window of the selected frame.
    Note that you cannot test for minibufferness of an arbitrary window
-   by comparing against this; but you can test for minibufferness of
-   the selected window or of any window that is displayed.  */
+   by comparing against this; use the MINI_WINDOW_P macro instead.  */
 
 extern Lisp_Object minibuf_window;
 
@@ -247,3 +247,7 @@ extern int windows_or_buffers_changed;
 /* Number of windows displaying the selected buffer.
    Normally this is 1, but it can be more.  */
 extern int buffer_shared;
+
+/* If *ROWS or *COLS are too small a size for FRAME, set them to the
+   minimum allowable size.  */
+extern void check_frame_size ( /* FRAME_PTR frame, int *rows, int *cols */ );