Merge from emacs--devo--0

Patches applied:

 * emacs--devo--0  (patch 814-815)

   - Update from CVS

Revision: emacs@sv.gnu.org/emacs--unicode--0--patch-232

5 files changed, 182 insertions, 54 deletions

diff --git a/src/ChangeLog b/src/ChangeLog
index 76c8c8ef163..af29937753c 100644
--- a/src/ChangeLog
+++ b/src/ChangeLog
@@ -1,3 +1,46 @@
+2007-07-17  Martin Rudalics  <rudalics@gmx.at>
+
+        * window.c (Fdisplay_buffer): If largest or LRU window is the
+        only window, split it even if it is not eligible for splitting.
+        This restores the original behavior broken by the 2007-07-15
+        change.
+
+2007-07-17  Glenn Morris  <rgm@gnu.org>
+
+        * abbrev.c (abbrev_check_chars): New function.
+        (Fdefine_global_abbrev, Fdefine_mode_abbrev): Call
+        abbrev_check_chars to check abbrev characters are word
+        constituents.  Doc fix.
+
+2007-07-17  Stefan Monnier  <monnier@iro.umontreal.ca>
+
+        * process.c (Fstart_process, Fmake_network_process)
+        (read_process_output): Fix up last changes.
+
+2007-07-16  Eli Zaretskii  <eliz@gnu.org>
+
+        * makefile.w32-in (clean): Don't delete *~.
+
+2007-07-16  Andreas Schwab  <schwab@suse.de>
+
+        * window.c (Fdisplay_buffer): Use NILP.
+        (Fset_window_scroll_bars): Likewise.
+
+2007-07-15  Martin Rudalics  <rudalics@gmx.at>
+
+        * window.c (window_min_size_2): New function.
+        (window_min_size_1, size_window, Fdisplay_buffer)
+        (Fsplit_window, adjust_window_trailing_edge): Use it to avoid
+        windows without mode- or header-lines when window-min-height is
+        too small.
+        (size_window): Reset nodelete_p after testing it, following an
+        earlier note by Kim F. Storm.
+        (display_buffer): Do not set split_height_threshold to twice the
+        value of window_min_height to avoid changing the value of a
+        customizable variable.  Rather explicitly check whether the
+        height of the window that shall be splitted is at least as large
+        as split_height_threshold.
+
 2007-07-14  Jason Rumney  <jasonr@gnu.org>
 
         * process.c [WINDOWSNT]: Don't undefine AF_INET6.
diff --git a/src/abbrev.c b/src/abbrev.c
index cb8e334591c..dd075364507 100644
--- a/src/abbrev.c
+++ b/src/abbrev.c
@@ -172,12 +172,79 @@ overwrite a non-system abbreviation of the same name.  */)
   return name;
 }
 
+/* Check if the characters in ABBREV have word syntax in either the
+ * current (if global == 0) or standard syntax table. */
+static void
+abbrev_check_chars (abbrev, global)
+     Lisp_Object abbrev;
+     int global;
+{
+  int i, i_byte, len, nbad = 0;
+  int j, found, nuniq = 0;
+  char *badchars, *baduniq;
+
+  CHECK_STRING (abbrev);
+  len = SCHARS (abbrev);
+
+  badchars = (char *) alloca (len + 1);
+
+  for (i = 0, i_byte = 0; i < len; )
+    {
+      int c;
+
+      FETCH_STRING_CHAR_ADVANCE (c, abbrev, i, i_byte);
+
+      if (global)
+        {
+          /* Copied from SYNTAX in syntax.h, except using FOLLOW_PARENT. */
+          Lisp_Object syntax_temp
+            = SYNTAX_ENTRY_FOLLOW_PARENT (Vstandard_syntax_table, c);
+          if ( (CONSP (syntax_temp)
+                ? (enum syntaxcode) (XINT (XCAR (syntax_temp)) & 0xff)
+                : Swhitespace) != Sword ) badchars[nbad++] = c;
+        }
+      else if (SYNTAX (c) != Sword)
+        badchars[nbad++] = c;
+    }
+
+  if (nbad == 0) return;
+
+  baduniq = (char *) alloca (nbad + 1);
+
+  for (i = 0; i < nbad; i++)
+    {
+      found = 0;
+
+      for (j = 0; j < nuniq; j++)
+        {
+          if (badchars[i] == baduniq[j])
+            {
+              found = 1;
+              break;
+            }
+        }
+
+      if (found) continue ;
+
+      baduniq[nuniq++] = badchars[i];
+    }
+
+  baduniq[nuniq] = '\0';
+
+  error ("Some abbrev characters (%s) are not word constituents %s",
+         baduniq, global ? "in the standard syntax" : "in this mode" );
+}
+
 DEFUN ("define-global-abbrev", Fdefine_global_abbrev, Sdefine_global_abbrev, 2, 2,
        "sDefine global abbrev: \nsExpansion for %s: ",
-       doc: /* Define ABBREV as a global abbreviation for EXPANSION.  */)
+       doc: /* Define ABBREV as a global abbreviation for EXPANSION.
+The characters in ABBREV must all be word constituents in the standard
+syntax table.  */)
      (abbrev, expansion)
      Lisp_Object abbrev, expansion;
 {
+  abbrev_check_chars (abbrev, 1);
+
   Fdefine_abbrev (Vglobal_abbrev_table, Fdowncase (abbrev),
                   expansion, Qnil, make_number (0), Qnil);
   return abbrev;
@@ -185,13 +252,16 @@ DEFUN ("define-global-abbrev", Fdefine_global_abbrev, Sdefine_global_abbrev, 2,
 
 DEFUN ("define-mode-abbrev", Fdefine_mode_abbrev, Sdefine_mode_abbrev, 2, 2,
        "sDefine mode abbrev: \nsExpansion for %s: ",
-       doc: /* Define ABBREV as a mode-specific abbreviation for EXPANSION.  */)
+       doc: /* Define ABBREV as a mode-specific abbreviation for EXPANSION.
+The characters in ABBREV must all be word-constituents in the current mode.  */)
      (abbrev, expansion)
      Lisp_Object abbrev, expansion;
 {
   if (NILP (current_buffer->abbrev_table))
     error ("Major mode has no abbrev table");
 
+  abbrev_check_chars (abbrev, 0);
+
   Fdefine_abbrev (current_buffer->abbrev_table, Fdowncase (abbrev),
                   expansion, Qnil, make_number (0), Qnil);
   return abbrev;
diff --git a/src/makefile.w32-in b/src/makefile.w32-in
index 280429b5a71..ea5382ff9f3 100644
--- a/src/makefile.w32-in
+++ b/src/makefile.w32-in
@@ -257,8 +257,10 @@ install:        $(ALL)
 #
 # Maintenance
 #
+# We used to delete *~, s/*~, m/*~ here, but that might inadvertently
+# remove precious files if it happens to match their short 8+3 aliases.
 clean:
-        - $(DEL) *~ "s/*~" "m/*~"
+        - $(DEL) "s/*.h~" "m/*.h~"
         - $(DEL) $(COMPILER_TEMP_FILES)
         - $(DEL_TREE) $(OBJDIR)
         - $(DEL) stamp_BLD
diff --git a/src/process.c b/src/process.c
index 5551c0610d0..30cc13cfb2c 100644
--- a/src/process.c
+++ b/src/process.c
@@ -1775,7 +1775,7 @@ usage: (start-process NAME BUFFER PROGRAM &rest PROGRAM-ARGS)  */)
   XPROCESS (proc)->encoding_buf = make_uninit_string (0);
 
   XPROCESS (proc)->inherit_coding_system_flag
-    = (NILP (buffer) || !inherit_process_coding_system);
+    = !(NILP (buffer) || !inherit_process_coding_system);
 
   create_process (proc, (char **) new_argv, current_dir);
 
@@ -3547,7 +3547,7 @@ usage: (make-network-process &rest ARGS)  */)
   p->encoding_buf = make_uninit_string (0);
 
   p->inherit_coding_system_flag
-    = (!NILP (tem) || NILP (buffer) || !inherit_process_coding_system);
+    = !(!NILP (tem) || NILP (buffer) || !inherit_process_coding_system);
 
   UNGCPRO;
   return proc;
@@ -5176,7 +5176,7 @@ read_process_output (proc, channel)
           p->decoding_carryover = coding->carryover_bytes;
         }
       /* Adjust the multibyteness of TEXT to that of the filter.  */
-      if (p->filter_multibyte != STRING_MULTIBYTE (text))
+      if (!p->filter_multibyte != !STRING_MULTIBYTE (text))
         text = (STRING_MULTIBYTE (text)
                 ? Fstring_as_unibyte (text)
                 : Fstring_to_multibyte (text));
diff --git a/src/window.c b/src/window.c
index 42a33828d8d..59b70152b09 100644
--- a/src/window.c
+++ b/src/window.c
@@ -62,6 +62,7 @@ static void window_scroll P_ ((Lisp_Object, int, int, int));
 static void window_scroll_pixel_based P_ ((Lisp_Object, int, int, int));
 static void window_scroll_line_based P_ ((Lisp_Object, int, int, int));
 static int window_min_size_1 P_ ((struct window *, int));
+static int window_min_size_2 P_ ((struct window *, int));
 static int window_min_size P_ ((struct window *, int, int, int *));
 static void size_window P_ ((Lisp_Object, int, int, int, int, int));
 static int freeze_window_start P_ ((struct window *, void *));
@@ -2553,7 +2554,6 @@ check_frame_size (frame, rows, cols)
     *cols = MIN_SAFE_WINDOW_WIDTH;
 }
 
-
 /* Value is non-zero if window W is fixed-size.  WIDTH_P non-zero means
    check if W's width can be changed, otherwise check W's height.
    CHECK_SIBLINGS_P non-zero means check resizablity of WINDOW's
@@ -2655,6 +2655,33 @@ window_fixed_size_p (w, width_p, check_siblings_p)
   return fixed_p;
 }
 
+/* Return the minimum size for leaf window W.  WIDTH_P non-zero means
+   take into account fringes and the scrollbar of W.  WIDTH_P zero
+   means take into account mode-line and header-line of W.  Return 1
+   for the minibuffer.  */
+
+static int
+window_min_size_2 (w, width_p)
+     struct window *w;
+     int width_p;
+{
+  int size;
+  
+  if (width_p)
+    size = max (window_min_width,
+                (MIN_SAFE_WINDOW_WIDTH
+                 + WINDOW_FRINGE_COLS (w)
+                 + WINDOW_SCROLL_BAR_COLS (w)));
+  else if (MINI_WINDOW_P (w))
+    size = 1;
+  else
+    size = max (window_min_height,
+                (MIN_SAFE_WINDOW_HEIGHT
+                 + (WINDOW_WANTS_MODELINE_P (w) ? 1 : 0)
+                 + (WINDOW_WANTS_HEADER_LINE_P (w) ? 1 : 0 )));
+
+  return size;
+}
 
 /* Return the minimum size of window W, not taking fixed-width windows
    into account.  WIDTH_P non-zero means return the minimum width,
@@ -2724,22 +2751,7 @@ window_min_size_1 (w, width_p)
         }
     }
   else
-    {
-      if (width_p)
-        size = max (window_min_width,
-                    (MIN_SAFE_WINDOW_WIDTH
-                     + WINDOW_FRINGE_COLS (w)
-                     + WINDOW_SCROLL_BAR_COLS (w)));
-      else
-        {
-          if (MINI_WINDOW_P (w)
-              || (!WINDOW_WANTS_MODELINE_P (w)
-                  && !WINDOW_WANTS_HEADER_LINE_P (w)))
-            size = 1;
-          else
-            size = window_min_height;
-        }
-    }
+    size = window_min_size_2 (w, width_p);
 
   return size;
 }
@@ -2981,11 +2993,6 @@ size_window (window, size, width_p, nodelete_p, first_only, last_only)
   Lisp_Object child, *forward, *sideward;
   int old_size, min_size, safe_min_size;
 
-  /* We test nodelete_p != 2 and nodelete_p != 1 below, so it
-     seems like it's too soon to do this here.  ++KFS.  */
-  if (nodelete_p == 2)
-    nodelete_p = 0;
-
   check_min_window_sizes ();
   size = max (0, size);
 
@@ -2996,22 +3003,23 @@ size_window (window, size, width_p, nodelete_p, first_only, last_only)
     {
       old_size = WINDOW_TOTAL_COLS (w);
       min_size = window_min_width;
-      /* Ensure that there is room for the scroll bar and fringes!
-         We may reduce display margins though.  */
-      safe_min_size = (MIN_SAFE_WINDOW_WIDTH
-                       + WINDOW_FRINGE_COLS (w)
-                       + WINDOW_SCROLL_BAR_COLS (w));
+      safe_min_size = window_min_size_2 (w, 1);
     }
   else
     {
       old_size = XINT (w->total_lines);
       min_size = window_min_height;
-      safe_min_size = MIN_SAFE_WINDOW_HEIGHT;
+      safe_min_size = window_min_size_2 (w, 0);
     }
 
   if (old_size < min_size && nodelete_p != 2)
     w->too_small_ok = Qt;
 
+  /* Move the following test here since otherwise the
+     preceding test doesn't make sense.  martin. */
+  if (nodelete_p == 2)
+    nodelete_p = 0;
+
   /* Maybe delete WINDOW if it's too small.  */
   if (nodelete_p != 1 && !NILP (w->parent))
     {
@@ -3708,9 +3716,6 @@ displayed.  */)
       frames = Qnil;
       if (FRAME_MINIBUF_ONLY_P (f))
         XSETFRAME (frames, last_nonminibuf_frame);
-      /* Don't try to create a window if we would get an error.  */
-      if (split_height_threshold < window_min_height << 1)
-        split_height_threshold = window_min_height << 1;
 
       /* Note that both Fget_largest_window and Fget_lru_window
          ignore minibuffers and dedicated windows.
@@ -3733,25 +3738,30 @@ displayed.  */)
       else
         window = Fget_largest_window (frames, Qt);
 
-      /* If we got a tall enough full-width window that can be split,
-         split it.  */
+      /* If the largest window is tall enough, full-width, and either eligible
+         for splitting or the only window, split it.  */
       if (!NILP (window)
           && ! FRAME_NO_SPLIT_P (XFRAME (XWINDOW (window)->frame))
-          && window_height (window) >= split_height_threshold
-          && WINDOW_FULL_WIDTH_P (XWINDOW (window)))
+          && WINDOW_FULL_WIDTH_P (XWINDOW (window))
+          && (window_height (window) >= split_height_threshold
+              || (NILP (XWINDOW (window)->parent)))
+          && (window_height (window)
+              >= (2 * window_min_size_2 (XWINDOW (window), 0))))
         window = Fsplit_window (window, Qnil, Qnil);
       else
         {
           Lisp_Object upper, other;
 
           window = Fget_lru_window (frames, Qt);
-          /* If the LRU window is selected, and big enough,
-             and can be split, split it.  */
+          /* If the LRU window is tall enough, and either eligible for splitting
+          and selected or the only window, split it.  */
           if (!NILP (window)
               && ! FRAME_NO_SPLIT_P (XFRAME (XWINDOW (window)->frame))
-              && (EQ (window, selected_window)
-                  || EQ (XWINDOW (window)->parent, Qnil))
-              && window_height (window) >= window_min_height << 1)
+              && ((EQ (window, selected_window)
+                   && window_height (window) >= split_height_threshold)
+                  || (NILP (XWINDOW (window)->parent)))
+              && (window_height (window)
+                  >= (2 * window_min_size_2 (XWINDOW (window), 0))))
             window = Fsplit_window (window, Qnil, Qnil);
           else
             window = Fget_lru_window (frames, Qnil);
@@ -4000,9 +4010,11 @@ See Info node `(elisp)Splitting Windows' for more details and examples.*/)
 
   if (NILP (horflag))
     {
-      if (size_int < window_min_height)
+      int window_safe_height = window_min_size_2 (o, 0);
+      
+      if (size_int < window_safe_height)
         error ("Window height %d too small (after splitting)", size_int);
-      if (size_int + window_min_height > XFASTINT (o->total_lines))
+      if (size_int + window_safe_height > XFASTINT (o->total_lines))
         error ("Window height %d too small (after splitting)",
                XFASTINT (o->total_lines) - size_int);
       if (NILP (o->parent)
@@ -4015,10 +4027,11 @@ See Info node `(elisp)Splitting Windows' for more details and examples.*/)
     }
   else
     {
-      if (size_int < window_min_width)
+      int window_safe_width = window_min_size_2 (o, 1);
+      
+      if (size_int < window_safe_width)
         error ("Window width %d too small (after splitting)", size_int);
-
-      if (size_int + window_min_width > XFASTINT (o->total_cols))
+      if (size_int + window_safe_width > XFASTINT (o->total_cols))
         error ("Window width %d too small (after splitting)",
                XFASTINT (o->total_cols) - size_int);
       if (NILP (o->parent)
@@ -4499,7 +4512,7 @@ adjust_window_trailing_edge (window, delta, horiz_flag)
 
       /* Don't make this window too small.  */
       if (XINT (CURSIZE (window)) + delta
-          < (horiz_flag ? window_min_width : window_min_height))
+          < window_min_size_2 (XWINDOW (window), horiz_flag))
         {
           Fset_window_configuration (old_config);
           error ("Cannot adjust window size as specified");
@@ -6897,7 +6910,7 @@ Fourth parameter HORIZONTAL-TYPE is currently unused.  */)
         vertical_type = Qnil;
     }
 
-  if (!(EQ (vertical_type, Qnil)
+  if (!(NILP (vertical_type)
         || EQ (vertical_type, Qleft)
         || EQ (vertical_type, Qright)
         || EQ (vertical_type, Qt)))
@@ -7589,4 +7602,4 @@ keys_of_window ()
 }
 
 /* arch-tag: 90a9c576-0590-48f1-a5f1-6c96a0452d9f
-   (do not change this comment) */
+   (do not change thisc omment) */