Revision: miles@gnu.org--gnu-2005/emacs--unicode--0--patch-81

Merge from emacs--cvs-trunk--0

Patches applied:

 * emacs--cvs-trunk--0  (patch 532-541)

   - Update from CVS
   - Merge from gnus--rel--5.10

 * gnus--rel--5.10  (patch 112-115)

   - Update from CVS

12 files changed, 590 insertions, 162 deletions

diff --git a/src/ChangeLog b/src/ChangeLog
index 7faeafe2329..99c9d951370 100644
--- a/src/ChangeLog
+++ b/src/ChangeLog
@@ -1,3 +1,75 @@
+2005-09-11  Chris Prince  <cprince@gmail.com>  (tiny change)
+
+        * w32term.c (x_bitmap_icon): Load small icons too.
+
+2005-09-10  Romain Francoise  <romain@orebokech.com>
+
+        * buffer.c (init_buffer): Grow buffer to add directory separator
+        and terminal zero.  Fix typos.
+
+2005-09-10  Eli Zaretskii  <eliz@gnu.org>
+
+        * buffer.c (init_buffer): Fix error message for failed call to
+        get_current_dir_name.
+        (get_current_dir_name): Remove prototype.
+
+        * xsmfns.c: (get_current_dir_name): Remove prototype.
+
+        * lisp.h: (get_current_dir_name) [!HAVE_GET_CURRENT_DIR_NAME]: Add
+        prototype.
+
+        * sysdep.c [WINDOWSNT]: Add prototype for getwd.
+        Don't #undef NULL after including blockinput.h.
+
+        * config.in: Regenerated.
+
+2005-09-10  Giuseppe Scrivano  <gscrivano@gmail.com>
+
+        Remove the MAXPATHLEN limitations:
+
+        * sysdep.c (get_current_dir_name) [!HAVE_GET_CURRENT_DIR_NAME]:
+        New function.
+
+        * buffer.c (init_buffer): Use it.
+
+        * xsmfns.c (smc_save_yourself_CB): Ditto.
+
+2005-09-09  Kim F. Storm  <storm@cua.dk>
+
+        * doc.c (Fsubstitute_command_keys): Lookup key binding for
+        commands that are remapped from some other command.
+
+        * xdisp.c (try_window_reusing_current_matrix): Clear mode_line_p
+        flag in disabled rows below the window.
+
+        * frame.h (struct frame): New member updated_p.
+
+        * xdisp.c (redisplay_internal): Mark updated frames in new updated_p
+        member.  Remove local `updated' array and associated variables.
+
+2005-09-07  Kim F. Storm  <storm@cua.dk>
+
+        * xdisp.c (handle_display_prop): Respect overlay window property.
+
+        * xdisp.c (try_window): Remove superfluous cursor_height calculation.
+        Fixes crash reported by YAMAMOTO Mitsuharu.
+
+2005-09-06  YAMAMOTO Mitsuharu  <mituharu@math.s.chiba-u.ac.jp>
+
+        * macterm.c (struct xlfdpat_block, struct xlfdpat): New structs.
+        (xlfdpat_destroy, xlfdpat_create, xlfdpat_exact_p)
+        (xlfdpat_block_match_1, xlfdpat_match): New functions.
+        (xlfdpat_block_match): New macro.
+        (mac_to_x_fontname): Don't use tolower for non-ASCII characters.
+        (x_font_name_to_mac_font_name): Set coding.dst_multibyte to 0.
+        (add_font_name_table_entry): Increase font_name_table_size more
+        rapidly.
+        (mac_c_string_match): Remove function.
+        (mac_do_list_fonts): Use XLFD pattern match instead of regular
+        expression match.
+
+        * xfaces.c (xstrlwr): Don't use tolower for non-ASCII characters.
+
 2005-09-03  Richard M. Stallman  <rms@gnu.org>
 
         * xdisp.c (redisplay_internal): Make UPDATED as long as needed.
diff --git a/src/buffer.c b/src/buffer.c
index 3450e88c72d..ae2a584e506 100644
--- a/src/buffer.c
+++ b/src/buffer.c
@@ -32,10 +32,6 @@ Boston, MA 02110-1301, USA.  */
 extern int errno;
 #endif
 
-#ifndef MAXPATHLEN
-/* in 4.1 [probably SunOS? -stef] , param.h fails to define this. */
-#define MAXPATHLEN 1024
-#endif /* not MAXPATHLEN */
 
 #ifdef HAVE_UNISTD_H
 #include <unistd.h>
@@ -5131,7 +5127,6 @@ init_buffer_once ()
 void
 init_buffer ()
 {
-  char buf[MAXPATHLEN + 1];
   char *pwd;
   struct stat dotstat, pwdstat;
   Lisp_Object temp;
@@ -5154,40 +5149,28 @@ init_buffer ()
   if (NILP (buffer_defaults.enable_multibyte_characters))
     Fset_buffer_multibyte (Qnil);
 
-  /* If PWD is accurate, use it instead of calling getwd.  PWD is
-     sometimes a nicer name, and using it may avoid a fatal error if a
-     parent directory is searchable but not readable.  */
-  if ((pwd = getenv ("PWD")) != 0
-      && (IS_DIRECTORY_SEP (*pwd) || (*pwd && IS_DEVICE_SEP (pwd[1])))
-      && stat (pwd, &pwdstat) == 0
-      && stat (".", &dotstat) == 0
-      && dotstat.st_ino == pwdstat.st_ino
-      && dotstat.st_dev == pwdstat.st_dev
-      && strlen (pwd) < MAXPATHLEN)
-    strcpy (buf, pwd);
-#ifdef HAVE_GETCWD
-  else if (getcwd (buf, MAXPATHLEN+1) == 0)
-    fatal ("`getcwd' failed: %s\n", strerror (errno));
-#else
-  else if (getwd (buf) == 0)
-    fatal ("`getwd' failed: %s\n", buf);
-#endif
+  pwd = get_current_dir_name ();
+
+  if (!pwd)
+    fatal ("`get_current_dir_name' failed: %s\n", strerror (errno));
 
 #ifndef VMS
   /* Maybe this should really use some standard subroutine
      whose definition is filename syntax dependent.  */
-  rc = strlen (buf);
-  if (!(IS_DIRECTORY_SEP (buf[rc - 1])))
+  rc = strlen (pwd);
+  if (!(IS_DIRECTORY_SEP (pwd[rc - 1])))
     {
-      buf[rc] = DIRECTORY_SEP;
-      buf[rc + 1] = '\0';
+      /* Grow buffer to add directory separator and '\0'.  */
+      pwd = (char *) xrealloc (pwd, rc + 2);
+      pwd[rc] = DIRECTORY_SEP;
+      pwd[rc + 1] = '\0';
     }
 #endif /* not VMS */
 
-  current_buffer->directory = make_unibyte_string (buf, strlen (buf));
+  current_buffer->directory = make_unibyte_string (pwd, strlen (pwd));
   if (! NILP (buffer_defaults.enable_multibyte_characters))
-    /* At this momemnt, we still don't know how to decode the
-       direcotry name.  So, we keep the bytes in multibyte form so
+    /* At this moment, we still don't know how to decode the
+       directory name.  So, we keep the bytes in multibyte form so
        that ENCODE_FILE correctly gets the original bytes.  */
     current_buffer->directory
       = string_to_multibyte (current_buffer->directory);
@@ -5206,6 +5189,8 @@ init_buffer ()
 
   temp = get_minibuffer (0);
   XBUFFER (temp)->directory = current_buffer->directory;
+
+  free (pwd);
 }
 
 /* initialize the buffer routines */
diff --git a/src/config.in b/src/config.in
index f2afed2ecb1..b5b700c69bf 100644
--- a/src/config.in
+++ b/src/config.in
@@ -221,6 +221,9 @@ Boston, MA 02110-1301, USA.  */
 /* Define to 1 if you have the `getwd' function. */
 #undef HAVE_GETWD
 
+/* Define to 1 if you have the `get_current_dir_name' function. */
+#undef HAVE_GET_CURRENT_DIR_NAME
+
 /* Define to 1 if you have the ungif library (-lungif). */
 #undef HAVE_GIF
 
diff --git a/src/doc.c b/src/doc.c
index 0a455fed37a..82a2391c424 100644
--- a/src/doc.c
+++ b/src/doc.c
@@ -57,6 +57,8 @@ static Lisp_Object Vbuild_files;
 
 extern Lisp_Object Voverriding_local_map;
 
+extern Lisp_Object Qremap;
+
 /* For VMS versions with limited file name syntax,
    convert the name to something VMS will allow.  */
 static void
@@ -812,6 +814,7 @@ thus, \\=\\=\\=\\= puts \\=\\= into the output, and \\=\\=\\=\\[ puts \\=\\[ int
       else if (strp[0] == '\\' && strp[1] == '[')
         {
           int start_idx;
+          int follow_remap = 1;
 
           changed = 1;
           strp += 2;            /* skip \[ */
@@ -830,11 +833,21 @@ thus, \\=\\=\\=\\= puts \\=\\= into the output, and \\=\\=\\=\\[ puts \\=\\[ int
           idx = strp - SDATA (string);
           name = Fintern (make_string (start, length_byte), Qnil);
 
+        do_remap:
           /* Ignore remappings unless there are no ordinary bindings. */
           tem = Fwhere_is_internal (name, keymap, Qt, Qnil, Qt);
           if (NILP (tem))
             tem = Fwhere_is_internal (name, keymap, Qt, Qnil, Qnil);
 
+          if (VECTORP (tem) && XVECTOR (tem)->size > 1
+              && EQ (AREF (tem, 0), Qremap) && SYMBOLP (AREF (tem, 1))
+              && follow_remap)
+            {
+              name = AREF (tem, 1);
+              follow_remap = 0;
+              goto do_remap;
+            }
+
           /* Note the Fwhere_is_internal can GC, so we have to take
              relocation of string contents into account.  */
           strp = SDATA (string) + idx;
diff --git a/src/frame.h b/src/frame.h
index 2928b36f2f2..48cf61d3040 100644
--- a/src/frame.h
+++ b/src/frame.h
@@ -468,6 +468,9 @@ struct frame
   /* Set to non-zero if this frame has already been hscrolled during
      current redisplay.  */
   unsigned already_hscrolled_p : 1;
+
+  /* Set to non-zero when current redisplay has updated frame.  */
+  unsigned updated_p : 1;
 };
 
 #ifdef MULTI_KBOARD
diff --git a/src/lisp.h b/src/lisp.h
index 0346c8fd0d3..1cefd7ba4b5 100644
--- a/src/lisp.h
+++ b/src/lisp.h
@@ -3141,6 +3141,9 @@ EXFUN (Fx_popup_dialog, 3);
 extern void syms_of_xmenu P_ ((void));
 
 /* defined in sysdep.c */
+#ifndef HAVE_GET_CURRENT_DIR_NAME
+extern char *get_current_dir_name P_ ((void));
+#endif
 extern void stuff_char P_ ((char c));
 extern void init_sigio P_ ((int));
 extern void request_sigio P_ ((void));
diff --git a/src/macterm.c b/src/macterm.c
index 099b69bfb09..d9b533a9b8c 100644
--- a/src/macterm.c
+++ b/src/macterm.c
@@ -6100,6 +6100,335 @@ x_wm_set_icon_position (f, icon_x, icon_y)
 
 
 /***********************************************************************
+                          XLFD Pattern Match
+ ***********************************************************************/
+
+/* An XLFD pattern is divided into blocks delimited by '*'.  This
+   structure holds information for each block.  */
+struct xlfdpat_block
+{
+  /* Length of the pattern string in this block.  Non-zero except for
+     the first and the last blocks.  */
+  int len;
+
+  /* Pattern string except the last character in this block.  The last
+     character is replaced with NUL in order to use it as a
+     sentinel.  */
+  unsigned char *pattern;
+
+  /* Last character of the pattern string.  Must not be '?'.  */
+  unsigned char last_char;
+
+  /* One of the tables for the Boyer-Moore string search.  It
+     specifies the number of positions to proceed for each character
+     with which the match fails.  */
+  int skip[256];
+
+  /* The skip value for the last character in the above `skip' is
+     assigned to `infinity' in order to simplify a loop condition.
+     The original value is saved here.  */
+  int last_char_skip;
+};
+
+struct xlfdpat
+{
+  /* Normalized pattern string.  "Normalized" means that capital
+     letters are lowered, blocks are not empty except the first and
+     the last ones, and trailing '?'s in a block that is not the last
+     one are moved to the next one.  The last character in each block
+     is replaced with NUL.  */
+  unsigned char *buf;
+
+  /* Number of characters except '*'s and trailing '?'s in the
+     normalized pattern string.  */
+  int nchars;
+
+  /* Number of trailing '?'s in the normalized pattern string.  */
+  int trailing_anychars;
+
+  /* Number of blocks and information for each block.  The latter is
+     NULL if the pattern is exact (no '*' or '?' in it).  */
+  int nblocks;
+  struct xlfdpat_block *blocks;
+};
+
+static void
+xlfdpat_destroy (pat)
+     struct xlfdpat *pat;
+{
+  if (pat)
+    {
+      if (pat->buf)
+        {
+          if (pat->blocks)
+            xfree (pat->blocks);
+          xfree (pat->buf);
+        }
+      xfree (pat);
+    }
+}
+
+static struct xlfdpat *
+xlfdpat_create (pattern)
+     char *pattern;
+{
+  struct xlfdpat *pat;
+  int nblocks, i, skip;
+  unsigned char last_char, *p, *q, *anychar_head;
+  struct xlfdpat_block *blk;
+
+  pat = xmalloc (sizeof (struct xlfdpat));
+  if (pat == NULL)
+    goto error;
+
+  pat->buf = xmalloc (strlen (pattern) + 1);
+  if (pat->buf == NULL)
+    goto error;
+
+  /* Normalize the pattern string and store it to `pat->buf'.  */
+  nblocks = 0;
+  anychar_head = NULL;
+  q = pat->buf;
+  last_char = '\0';
+  for (p = pattern; *p; p++)
+    {
+      unsigned char c = *p;
+
+      if (c == '*')
+        if (last_char == '*')
+          /*  ...a** -> ...a*  */
+          continue;
+        else
+          {
+            if (last_char == '?')
+              if (anychar_head > pat->buf && *(anychar_head - 1) == '*')
+                /*  ...*??* -> ...*??  */
+                continue;
+              else
+                /*  ...a??* -> ...a*??  */
+                {
+                  *anychar_head++ = '*';
+                  c = '?';
+                }
+            nblocks++;
+          }
+      else if (c == '?')
+        {
+          if (last_char != '?')
+            anychar_head = q;
+        }
+      else
+        /* On Mac OS X 10.3, tolower also converts non-ASCII
+           characters for some locales.  */
+        if (isascii (c))
+          c = tolower (c);
+
+      *q++ = last_char = c;
+    }
+  *q = '\0';
+  nblocks++;
+  pat->nblocks = nblocks;
+  if (last_char != '?')
+    pat->trailing_anychars = 0;
+  else
+    {
+      pat->trailing_anychars = q - anychar_head;
+      q = anychar_head;
+    }
+  pat->nchars = q - pat->buf - (nblocks - 1);
+
+  if (anychar_head == NULL && nblocks == 1)
+    {
+      /* The pattern is exact.  */
+      pat->blocks = NULL;
+      return pat;
+    }
+
+  pat->blocks = xmalloc (sizeof (struct xlfdpat_block) * nblocks);
+  if (pat->blocks == NULL)
+    goto error;
+
+  /* Divide the normalized pattern into blocks.  */
+  p = pat->buf;
+  for (blk = pat->blocks; blk < pat->blocks + nblocks - 1; blk++)
+    {
+      blk->pattern = p;
+      while (*p != '*')
+        p++;
+      blk->len = p - blk->pattern;
+      p++;
+    }
+  blk->pattern = p;
+  blk->len = q - blk->pattern;
+
+  /* Setup a table for the Boyer-Moore string search.  */
+  for (blk = pat->blocks; blk < pat->blocks + nblocks; blk++)
+    if (blk->len != 0)
+      {
+        blk->last_char = blk->pattern[blk->len - 1];
+        blk->pattern[blk->len - 1] = '\0';
+
+        for (skip = 1; skip < blk->len; skip++)
+          if (blk->pattern[blk->len - skip - 1] == '?')
+            break;
+
+        for (i = 0; i < 256; i++)
+          blk->skip[i] = skip;
+
+        p = blk->pattern + (blk->len - skip);
+        while (--skip > 0)
+          blk->skip[*p++] = skip;
+
+        blk->last_char_skip = blk->skip[blk->last_char];
+      }
+
+  return pat;
+
+ error:
+  xlfdpat_destroy (pat);
+  return NULL;
+}
+
+static INLINE int
+xlfdpat_exact_p (pat)
+     struct xlfdpat *pat;
+{
+  return (pat)->blocks == NULL;
+}
+
+/* Return the first string in STRING + 0, ..., STRING + START_MAX such
+   that the pattern in *BLK matches with its prefix.  Return NULL
+   there is no such strings.  STRING must be lowered in advance.  */
+
+static char *
+xlfdpat_block_match_1 (blk, string, start_max)
+     struct xlfdpat_block *blk;
+     unsigned char *string;
+     int start_max;
+{
+  int start, infinity;
+  unsigned char *p, *s;
+
+  xassert (blk->len > 0);
+  xassert (start_max + blk->len <= strlen (string));
+  xassert (blk->pattern[blk->len - 1] != '?');
+
+  /* See the comments in the function `boyer_moore' (search.c) for the
+     use of `infinity'.  */
+  infinity = start_max + blk->len + 1;
+  blk->skip[blk->last_char] = infinity;
+
+  start = 0;
+  do
+    {
+      /* Check the last character of the pattern. */
+      s = string + blk->len - 1;
+      do
+        {
+          start += blk->skip[*(s + start)];
+        }
+      while (start <= start_max);
+
+      if (start < infinity)
+        /* Couldn't find the last character.  */
+        return NULL;
+
+      /* No less than `infinity' means we could find the last
+         character at `s[start - infinity]'.  */
+      start -= infinity;
+
+      /* Check the remaining characters.  We prefer making no-'?'
+         cases faster because the use of '?' is really rare.  */
+      p = blk->pattern;
+      s = string + start;
+      do
+        {
+          while (*p++ == *s++)
+            ;
+        }
+      while (*(p - 1) == '?');
+
+      if (*(p - 1) == '\0')
+        /* Matched.  */
+        return string + start;
+
+      /* Didn't match.  */
+      start += blk->last_char_skip;
+    }
+  while (start <= start_max);
+
+  return NULL;
+}
+
+#define xlfdpat_block_match(b, s, m) \
+  ((b)->len == 1 ? memchr ((s), (b)->last_char, (m) + 1) \
+   : xlfdpat_block_match_1 (b, s, m))
+
+/* Check if XLFD pattern PAT, which is generated by `xfldpat_create',
+   matches with STRING.  STRING must be lowered in advance.  */
+
+static int
+xlfdpat_match (pat, string)
+     struct xlfdpat *pat;
+     unsigned char *string;
+{
+  int str_len, nblocks, i, start_max;
+  struct xlfdpat_block *blk;
+  unsigned char *s;
+
+  xassert (pat->nblocks > 0);
+
+  if (xlfdpat_exact_p (pat))
+    return strcmp (pat->buf, string) == 0;
+
+  /* The number of the characters in the string must not be smaller
+     than that in the pattern.  */
+  str_len = strlen (string);
+  if (str_len < pat->nchars + pat->trailing_anychars)
+    return 0;
+
+  /* Chop off the trailing '?'s.  */
+  str_len -= pat->trailing_anychars;
+
+  /* The last block.  When it is non-empty, it must match at the end
+     of the string.  */
+  nblocks = pat->nblocks;
+  blk = pat->blocks + (nblocks - 1);
+  if (nblocks == 1)
+    /* The last block is also the first one.  */
+    return (str_len == blk->len
+            && (blk->len == 0 || xlfdpat_block_match (blk, string, 0)));
+  else if (blk->len != 0)
+    if (!xlfdpat_block_match (blk, string + (str_len - blk->len), 0))
+      return 0;
+
+  /* The first block.  When it is non-empty, it must match at the
+     beginning of the string.  */
+  blk = pat->blocks;
+  if (blk->len != 0)
+    {
+      s = xlfdpat_block_match (blk, string, 0);
+      if (s == NULL)
+        return 0;
+      string = s + blk->len;
+    }
+
+  /* The rest of the blocks.  */
+  start_max = str_len - pat->nchars;
+  for (i = 1, blk++; i < nblocks - 1; i++, blk++)
+    {
+      s = xlfdpat_block_match (blk, string, start_max);
+      if (s == NULL)
+        return 0;
+      start_max -= s - string;
+      string = s + blk->len;
+    }
+
+  return 1;
+}
+
+
+/***********************************************************************
                                 Fonts
  ***********************************************************************/
 
@@ -6198,7 +6527,8 @@ mac_to_x_fontname (name, size, style, charset)
 {
   Str31 foundry, cs;
   Str255 family;
-  char xf[256], *result, *p;
+  char xf[256], *result;
+  unsigned char *p;
 
   if (sscanf (name, "%31[^-]-%255[^-]-%31s", foundry, family, cs) == 3)
     charset = cs;
@@ -6215,7 +6545,10 @@ mac_to_x_fontname (name, size, style, charset)
   result = xmalloc (strlen (foundry) + strlen (family) + strlen (xf) + 3 + 1);
   sprintf (result, "-%s-%s-%s", foundry, family, xf);
   for (p = result; *p; p++)
-    *p = tolower(*p);
+    /* On Mac OS X 10.3, tolower also converts non-ASCII characters
+       for some locales.  */
+    if (isascii (*p))
+      *p = tolower (*p);
   return result;
 }
 
@@ -6275,7 +6608,7 @@ x_font_name_to_mac_font_name (xf, mf, mf_decoded, style, cs)
     {
       setup_coding_system (coding_system, &coding);
       coding.src_multibyte = 1;
-      coding.dst_multibyte = 1;
+      coding.dst_multibyte = 0;
       coding.mode |= CODING_MODE_LAST_BLOCK;
       encode_coding (&coding, mf_decoded, mf,
                      strlen (mf_decoded), sizeof (Str255) - 1);
@@ -6290,13 +6623,13 @@ add_font_name_table_entry (char *font_name)
 {
   if (font_name_table_size == 0)
     {
-      font_name_table_size = 16;
+      font_name_table_size = 256;
       font_name_table = (char **)
         xmalloc (font_name_table_size * sizeof (char *));
     }
   else if (font_name_count + 1 >= font_name_table_size)
     {
-      font_name_table_size += 16;
+      font_name_table_size *= 2;
       font_name_table = (char **)
         xrealloc (font_name_table,
                   font_name_table_size * sizeof (char *));
@@ -6521,39 +6854,16 @@ static int xlfd_scalable_fields[] =
   };
 
 static Lisp_Object
-mac_c_string_match (regexp, string, nonspecial, exact)
-     Lisp_Object regexp;
-     const char *string, *nonspecial;
-     int exact;
-{
-  if (exact)
-    {
-      if (strcmp (string, nonspecial) == 0)
-        return build_string (string);
-    }
-  else if (strstr (string, nonspecial))
-    {
-      Lisp_Object str = build_string (string);
-
-      if (fast_string_match (regexp, str) >= 0)
-        return str;
-    }
-
-  return Qnil;
-}
-
-static Lisp_Object
 mac_do_list_fonts (pattern, maxnames)
      char *pattern;
      int maxnames;
 {
   int i, n_fonts = 0;
-  Lisp_Object font_list = Qnil, pattern_regex, fontname;
-  char *regex = (char *) alloca (strlen (pattern) * 2 + 3);
+  Lisp_Object font_list = Qnil;
+  struct xlfdpat *pat;
   char *scaled, *ptr;
   int scl_val[XLFD_SCL_LAST], *field, *val;
-  char *longest_start, *cur_start, *nonspecial;
-  int longest_len, exact;
+  int exact;
 
   if (font_name_table == NULL)  /* Initialize when first used.  */
     init_font_name_table ();
@@ -6611,61 +6921,17 @@ mac_do_list_fonts (pattern, maxnames)
   else
     scl_val[XLFD_SCL_PIXEL_SIZE] = -1;
 
-  ptr = regex;
-  *ptr++ = '^';
-
-  longest_start = cur_start = ptr;
-  longest_len = 0;
-  exact = 1;
-
-  /* Turn pattern into a regexp and do a regexp match.  Also find the
-     longest substring containing no special characters.  */
-  for (; *pattern; pattern++)
-    {
-      if (*pattern == '?' || *pattern == '*')
-        {
-          if (ptr - cur_start > longest_len)
-            {
-              longest_start = cur_start;
-              longest_len = ptr - cur_start;
-            }
-          exact = 0;
-
-          if (*pattern == '?')
-            *ptr++ = '.';
-          else /* if (*pattern == '*') */
-            {
-              *ptr++ = '.';
-              *ptr++ = '*';
-            }
-          cur_start = ptr;
-        }
-      else
-        *ptr++ = tolower (*pattern);
-    }
-
-  if (ptr - cur_start > longest_len)
-    {
-      longest_start = cur_start;
-      longest_len = ptr - cur_start;
-    }
-
-  *ptr = '$';
-  *(ptr + 1) = '\0';
-
-  nonspecial = xmalloc (longest_len + 1);
-  strncpy (nonspecial, longest_start, longest_len);
-  nonspecial[longest_len] = '\0';
+  pat = xlfdpat_create (pattern);
+  if (pat == NULL)
+    return Qnil;
 
-  pattern_regex = build_string (regex);
+  exact = xlfdpat_exact_p (pat);
 
   for (i = 0; i < font_name_count; i++)
     {
-      fontname = mac_c_string_match (pattern_regex, font_name_table[i],
-                                     nonspecial, exact);
-      if (!NILP (fontname))
+      if (xlfdpat_match (pat, font_name_table[i]))
         {
-          font_list = Fcons (fontname, font_list);
+          font_list = Fcons (build_string (font_name_table[i]), font_list);
           if (exact || maxnames > 0 && ++n_fonts >= maxnames)
             break;
         }
@@ -6675,6 +6941,8 @@ mac_do_list_fonts (pattern, maxnames)
           int former_len = ptr - font_name_table[i];
 
           scaled = xmalloc (strlen (font_name_table[i]) + 20 + 1);
+          if (scaled == NULL)
+            continue;
           memcpy (scaled, font_name_table[i], former_len);
           sprintf (scaled + former_len,
                    "-%d-%d-75-75-m-%d-%s",
@@ -6682,19 +6950,20 @@ mac_do_list_fonts (pattern, maxnames)
                    scl_val[XLFD_SCL_POINT_SIZE],
                    scl_val[XLFD_SCL_AVGWIDTH],
                    ptr + sizeof ("-0-0-0-0-m-0-") - 1);
-          fontname = mac_c_string_match (pattern_regex, scaled,
-                                         nonspecial, exact);
-          xfree (scaled);
-          if (!NILP (fontname))
+
+          if (xlfdpat_match (pat, scaled))
             {
-              font_list = Fcons (fontname, font_list);
+              font_list = Fcons (build_string (scaled), font_list);
+              xfree (scaled);
               if (exact || maxnames > 0 && ++n_fonts >= maxnames)
-                break;
+                  break;
             }
+          else
+            xfree (scaled);
         }
     }
 
-  xfree (nonspecial);
+  xlfdpat_destroy (pat);
 
   return font_list;
 }
diff --git a/src/sysdep.c b/src/sysdep.c
index e63ee904f14..c0ff47e3072 100644
--- a/src/sysdep.c
+++ b/src/sysdep.c
@@ -47,7 +47,6 @@ extern void srandom P_ ((unsigned int));
 #endif
 
 #include "blockinput.h"
-#undef NULL
 
 #ifdef MAC_OS8
 /* It is essential to include stdlib.h so that this file picks up
@@ -187,6 +186,7 @@ extern int quit_char;
 #define _P_WAIT 0
 int _CRTAPI1 _spawnlp (int, const char *, const char *, ...);
 int _CRTAPI1 _getpid (void);
+extern char *getwd (char *);
 #endif
 
 #ifdef NONSYSTEM_DIR_LIBRARY
@@ -258,6 +258,81 @@ void hft_reset ();
 
 SIGMASKTYPE sigprocmask_set;
 
+
+#ifndef HAVE_GET_CURRENT_DIR_NAME
+
+/* Return the current working directory.  Returns NULL on errors.
+   Any other returned value must be freed with free. This is used
+   only when get_current_dir_name is not defined on the system.  */
+char*
+get_current_dir_name ()
+{
+  char *buf;
+  char *pwd;
+  struct stat dotstat, pwdstat;
+  /* If PWD is accurate, use it instead of calling getwd.  PWD is
+     sometimes a nicer name, and using it may avoid a fatal error if a
+     parent directory is searchable but not readable.  */
+    if ((pwd = getenv ("PWD")) != 0
+      && (IS_DIRECTORY_SEP (*pwd) || (*pwd && IS_DEVICE_SEP (pwd[1])))
+      && stat (pwd, &pwdstat) == 0
+      && stat (".", &dotstat) == 0
+      && dotstat.st_ino == pwdstat.st_ino
+      && dotstat.st_dev == pwdstat.st_dev
+#ifdef MAXPATHLEN
+      && strlen (pwd) < MAXPATHLEN
+#endif
+      )
+    {
+      buf = (char *) malloc (strlen (pwd) + 1);
+      if (!buf)
+        return NULL;
+      strcpy (buf, pwd);
+    }
+#ifdef HAVE_GETCWD
+  else
+    {
+      size_t buf_size = 1024;
+      buf = (char *) malloc (buf_size);
+      if (!buf)
+        return NULL;
+      for (;;)
+        {
+          if (getcwd (buf, buf_size) == buf)
+            break;
+          if (errno != ERANGE)
+            {
+              int tmp_errno = errno;
+              free (buf);
+              errno = tmp_errno;
+              return NULL;
+            }
+          buf_size *= 2;
+          buf = (char *) realloc (buf, buf_size);
+          if (!buf)
+            return NULL;
+        }
+    }
+#else
+  else
+    {
+      /* We need MAXPATHLEN here.  */
+      buf = (char *) malloc (MAXPATHLEN + 1);
+      if (!buf)
+        return NULL;
+      if (getwd (buf) == NULL)
+        {
+          int tmp_errno = errno;
+          free (buf);
+          errno = tmp_errno;
+          return NULL;
+        }
+    }
+#endif
+  return buf;
+}
+#endif
+
 
 /* Specify a different file descriptor for further input operations.  */
 
diff --git a/src/w32term.c b/src/w32term.c
index 5d14d758f74..f0d5dc507ac 100644
--- a/src/w32term.c
+++ b/src/w32term.c
@@ -5418,16 +5418,25 @@ x_bitmap_icon (f, icon)
      struct frame *f;
      Lisp_Object icon;
 {
-  HANDLE hicon;
+  HANDLE main_icon;
+  HANDLE small_icon = NULL;
 
   if (FRAME_W32_WINDOW (f) == 0)
     return 1;
 
   if (NILP (icon))
-    hicon = LoadIcon (hinst, EMACS_CLASS);
+    main_icon = LoadIcon (hinst, EMACS_CLASS);
   else if (STRINGP (icon))
-    hicon = LoadImage (NULL, (LPCTSTR) SDATA (icon), IMAGE_ICON, 0, 0,
-                       LR_DEFAULTSIZE | LR_LOADFROMFILE);
+    {
+      /* Load the main icon from the named file.  */
+      main_icon = LoadImage (NULL, (LPCTSTR) SDATA (icon), IMAGE_ICON, 0, 0,
+                             LR_DEFAULTSIZE | LR_LOADFROMFILE);
+      /* Try to load a small icon to go with it.  */
+      small_icon = LoadImage (NULL, (LPCSTR) SDATA (icon), IMAGE_ICON,
+                              GetSystemMetrics (SM_CXSMICON),
+                              GetSystemMetrics (SM_CYSMICON),
+                              LR_LOADFROMFILE);
+    }
   else if (SYMBOLP (icon))
     {
       LPCTSTR name;
@@ -5447,16 +5456,21 @@ x_bitmap_icon (f, icon)
       else
         return 1;
 
-      hicon = LoadIcon (NULL, name);
+      main_icon = LoadIcon (NULL, name);
     }
   else
     return 1;
 
-  if (hicon == NULL)
+  if (main_icon == NULL)
     return 1;
 
   PostMessage (FRAME_W32_WINDOW (f), WM_SETICON, (WPARAM) ICON_BIG,
-               (LPARAM) hicon);
+               (LPARAM) main_icon);
+
+  /* If there is a small icon that goes with it, set that too.  */
+  if (small_icon)
+    PostMessage (FRAME_W32_WINDOW (f), WM_SETICON, (WPARAM) ICON_SMALL,
+                 (LPARAM) small_icon);
 
   return 0;
 }
diff --git a/src/xdisp.c b/src/xdisp.c
index 529dd7e4cd3..e4adb43d624 100644
--- a/src/xdisp.c
+++ b/src/xdisp.c
@@ -3431,7 +3431,7 @@ handle_display_prop (it)
     }
   else
     {
-      object = it->w->buffer;
+      XSETWINDOW (object, it->w);
       position = &it->current.pos;
     }
 
@@ -3452,6 +3452,9 @@ handle_display_prop (it)
   if (NILP (prop))
     return HANDLED_NORMALLY;
 
+  if (!STRINGP (it->string))
+    object = it->w->buffer;
+
   if (CONSP (prop)
       /* Simple properties.  */
       && !EQ (XCAR (prop), Qimage)
@@ -10718,13 +10721,9 @@ redisplay_internal (preserve_echo_area)
   if (consider_all_windows_p)
     {
       Lisp_Object tail, frame;
-      int i, n = 0, size = 5;
-      struct frame **updated;
 
       FOR_EACH_FRAME (tail, frame)
-        size++;
-
-      updated = (struct frame **) alloca (size * sizeof *updated);
+        XFRAME (frame)->updated_p = 0;
 
       /* Recompute # windows showing selected buffer.  This will be
          incremented each time such a window is displayed.  */
@@ -10786,15 +10785,7 @@ redisplay_internal (preserve_echo_area)
                     break;
 #endif
 
-                  if (n == size)
-                    {
-                      int nbytes = size * sizeof *updated;
-                      struct frame **p = (struct frame **) alloca (2 * nbytes);
-                      bcopy (updated, p, nbytes);
-                      size *= 2;
-                    }
-
-                  updated[n++] = f;
+                  f->updated_p = 1;
                 }
             }
         }
@@ -10804,12 +10795,15 @@ redisplay_internal (preserve_echo_area)
           /* Do the mark_window_display_accurate after all windows have
              been redisplayed because this call resets flags in buffers
              which are needed for proper redisplay.  */
-          for (i = 0; i < n; ++i)
+          FOR_EACH_FRAME (tail, frame)
             {
-              struct frame *f = updated[i];
-              mark_window_display_accurate (f->root_window, 1);
-              if (frame_up_to_date_hook)
-                frame_up_to_date_hook (f);
+              struct frame *f = XFRAME (frame);
+              if (f->updated_p)
+                {
+                  mark_window_display_accurate (f->root_window, 1);
+                  if (frame_up_to_date_hook)
+                    frame_up_to_date_hook (f);
+                }
             }
         }
     }
@@ -12925,12 +12919,11 @@ try_window (window, pos, check_margins)
   if (check_margins
       && !MINI_WINDOW_P (w))
     {
-      int this_scroll_margin, cursor_height;
+      int this_scroll_margin;
 
       this_scroll_margin = max (0, scroll_margin);
       this_scroll_margin = min (this_scroll_margin, WINDOW_TOTAL_LINES (w) / 4);
       this_scroll_margin *= FRAME_LINE_HEIGHT (it.f);
-      cursor_height = MATRIX_ROW (w->desired_matrix, w->cursor.vpos)->height;
 
       if ((w->cursor.y < this_scroll_margin
            && CHARPOS (pos) > BEGV)
@@ -13181,7 +13174,7 @@ try_window_reusing_current_matrix (w)
           /* Disable lines in the current matrix which are now
              below the window.  */
           for (++row; row < bottom_row; ++row)
-            row->enabled_p = 0;
+            row->enabled_p = row->mode_line_p = 0;
         }
 
       /* Update window_end_pos etc.; last_reused_text_row is the last
diff --git a/src/xfaces.c b/src/xfaces.c
index 6d805feacae..34bee3298ba 100644
--- a/src/xfaces.c
+++ b/src/xfaces.c
@@ -835,7 +835,10 @@ xstrlwr (s)
   unsigned char *p = s;
 
   for (p = s; *p; ++p)
-    *p = tolower (*p);
+    /* On Mac OS X 10.3, tolower also converts non-ASCII characters
+       for some locales.  */
+    if (isascii (*p))
+      *p = tolower (*p);
 
   return s;
 }
diff --git a/src/xsmfns.c b/src/xsmfns.c
index 4285dd76718..0215d562548 100644
--- a/src/xsmfns.c
+++ b/src/xsmfns.c
@@ -52,11 +52,6 @@ Boston, MA 02110-1301, USA.  */
 #include "termopts.h"
 #include "xterm.h"
 
-#ifndef MAXPATHLEN
-#define MAXPATHLEN 1024
-#endif /* not MAXPATHLEN */
-
-
 /* The user login name.  */
 
 extern Lisp_Object Vuser_login_name;
@@ -205,7 +200,7 @@ smc_save_yourself_CB (smcConn,
   int val_idx = 0;
   int props_idx = 0;
 
-  char cwd[MAXPATHLEN+1];
+  char *cwd = NULL;
   char *smid_opt;
 
   /* How to start a new instance of Emacs.  */
@@ -259,12 +254,9 @@ smc_save_yourself_CB (smcConn,
   props[props_idx]->vals[0].value = SDATA (Vuser_login_name);
   ++props_idx;
 
-  /* The current directory property, not mandatory.  */
-#ifdef HAVE_GETCWD
-  if (getcwd (cwd, MAXPATHLEN+1) != 0)
-#else
-  if (getwd (cwd) != 0)
-#endif
+  cwd = get_current_dir_name ();
+
+  if (cwd)
     {
       props[props_idx] = &prop_ptr[props_idx];
       props[props_idx]->name = SmCurrentDirectory;
@@ -281,6 +273,9 @@ smc_save_yourself_CB (smcConn,
 
   xfree (smid_opt);
 
+  if (cwd)
+    free (cwd);
+
   /* See if we maybe shall interact with the user.  */
   if (interactStyle != SmInteractStyleAny
       || ! shutdown