Merge from emacs--devo--0

Patches applied:

 * emacs--devo--0  (patch 793-802)

   - Update from CVS
   - Remove RCS keywords
   - Merge from emacs--rel--22

 * emacs--rel--22  (patch 42-50)

   - Update from CVS
   - Merge from gnus--rel--5.10
   - Gnus ChangeLog tweaks

 * gnus--rel--5.10  (patch 229-232)

   - Merge from emacs--devo--0, emacs--rel--22
   - ChangeLog tweak
   - Update from CVS

Revision: emacs@sv.gnu.org/emacs--multi-tty--0--patch-23

19 files changed, 1012 insertions, 75 deletions

diff --git a/src/ChangeLog b/src/ChangeLog
index a2e1e5b8484..4d2e7ccb375 100644
--- a/src/ChangeLog
+++ b/src/ChangeLog
@@ -1,3 +1,93 @@
+2007-06-16  Eli Zaretskii  <eliz@gnu.org>
+
+        * w32menu.c (add_menu_item): Escape `&' characters in menu items
+        and their keybindings.
+
+2007-06-15  Chong Yidong  <cyd@stupidchicken.com>
+
+        * composite.c (update_compositions): Fix last fix.
+
+2007-06-14  Jason Rumney  <jasonr@gnu.org>
+
+        * w32.c (get_process_times_fn): New function pointer.
+        (globals_of_w32): Intialize it if present in kernel32.dll.
+        (w32_get_internal_run_time): New function.
+
+        * editfns.c (Fget_internal_run_time) [WINDOWSNT]: Use it.
+
+2007-06-14  Kenichi Handa  <handa@etlken.m17n.org>
+
+        * composite.c (update_compositions): Check the validness of
+        compositions.
+
+2007-06-14  YAMAMOTO Mitsuharu  <mituharu@math.s.chiba-u.ac.jp>
+
+        * frame.h (struct frame) [MAC_OS]: New member external_tool_bar.
+        (FRAME_EXTERNAL_TOOL_BAR) [MAC_OS]: Use it.
+
+        * macfns.c (mac_window) [USE_MAC_TOOLBAR]: Set toolbar_win_gravity.
+        (x_set_tool_bar_lines) [USE_MAC_TOOLBAR]: Set FRAME_EXTERNAL_TOOL_BAR.
+
+        * macgui.h (USE_MAC_TOOLBAR): New define.
+
+        * macmenu.c [TARGET_API_MAC_CARBON] (menu_target_item_handler):
+        Return immediately unless popup is activated.
+
+        * macterm.c (x_draw_fringe_bitmap) [MAC_OSX]: Extend fringe
+        background to scroll bar gap.
+        (x_scroll_bar_create) [MAC_OSX]: Set bar->fringe_extended_p.
+        (XTset_vertical_scroll_bar) [MAC_OSX]: Put leftmost/rightmost
+        scroll bars on frame edge.  Check fringe background extension.
+        Don't clear extended fringe background area.
+        (TOOLBAR_IDENTIFIER, TOOLBAR_ICON_ITEM_IDENTIFIER)
+        (TOOLBAR_ITEM_COMMAND_ID_OFFSET, TOOLBAR_ITEM_COMMAND_ID_P)
+        (TOOLBAR_ITEM_COMMAND_ID_VALUE, TOOLBAR_ITEM_MAKE_COMMAND_ID):
+        [USE_MAC_TOOLBAR]: New macros.
+        (mac_move_window_with_gravity, mac_get_window_origin_with_gravity)
+        (mac_handle_toolbar_event, mac_image_spec_to_cg_image)
+        (mac_create_frame_tool_bar, update_frame_tool_bar, free_frame_tool_bar)
+        (mac_tool_bar_note_mouse_movement, mac_handle_toolbar_command_event)
+        [USE_MAC_TOOLBAR]: New functions.
+        (mac_handle_window_event) [USE_MAC_TOOLBAR]: Reposition window
+        manually if previous repositioning has failed.
+        (mac_handle_keyboard_event): Use precomputed event kind.
+        (XTread_socket) [USE_MAC_TOOLBAR]: Handle click in structure region
+        as tool bar item click.  Handle mouse movement over tool bar items.
+
+        * macterm.h (struct mac_output) [USE_MAC_TOOLBAR]: New member
+        toolbar_win_gravity.
+        (struct scroll_bar) [MAC_OSX]: New member fringe_extended_p.
+        (update_frame_tool_bar, free_frame_tool_bar) [USE_MAC_TOOLBAR]:
+        Add externs.
+
+        * xdisp.c (update_tool_bar, redisplay_tool_bar, redisplay_window)
+        [USE_MAC_TOOLBAR]: Sync with GTK+ tool bar display.
+
+2007-06-14  Chong Yidong  <cyd@stupidchicken.com>
+
+        * image.c (search_image_cache): Remove unused variable.
+
+2007-06-13  Chong Yidong  <cyd@stupidchicken.com>
+
+        * xfns.c, xmenu.c: Link to xaw3d if available.
+
+2007-06-13  YAMAMOTO Mitsuharu  <mituharu@math.s.chiba-u.ac.jp>
+
+        * dispextern.h (struct image) [HAVE_WINDOW_SYSTEM]: New members
+        frame_foreground and frame_background.
+
+        * image.c (lookup_image): Save frame foreground and background colors.
+        (search_image_cache): Check if saved and current frame colors match.
+
+2007-06-12  Stefan Monnier  <monnier@iro.umontreal.ca>
+
+        * regex.c (regex_compile): Remove the `regnum' counter.
+        Use bufp->re_nsub instead.  Add support for \(?N:RE\).
+
+2007-06-11  Stefan Monnier  <monnier@iro.umontreal.ca>
+
+        * term.c: Include intervals.h to declare Fget_text_property.
+
 2007-06-10  Jason Rumney  <jasonr@gnu.org>
 
         * w32fns.c (Fx_file_dialog): Take size from struct not pointer.
@@ -106,11 +196,11 @@
         New function.
         (init_dm_notification_handler) [MAC_OS_X_VERSION_MAX_ALLOWED >= 1030]:
         Register it.
-        (XTread_socket) [TARGET_API_MAC_CARBON]: Consolidate
-        SendEventToEventTarget calls.  Use FRAME_OUTER_TO_INNER_DIFF_X and
-        FRAME_OUTER_TO_INNER_DIFF_Y.  Move application activation handler
-        to mac_handle_application_event.  Move keyboard handler to
-        mac_handle_keyboard_event.
+        (XTread_socket) [TARGET_API_MAC_CARBON]:
+        Consolidate SendEventToEventTarget calls.
+        Use FRAME_OUTER_TO_INNER_DIFF_X and FRAME_OUTER_TO_INNER_DIFF_Y.
+        Move application activation handler to mac_handle_application_event.
+        Move keyboard handler to mac_handle_keyboard_event.
         (XTread_socket) [!TARGET_API_MAC_CARBON]: Use do_keystroke.
         (mac_initialize) [TARGET_API_MAC_CARBON]: Don't call
         init_command_handler.  Call install_application_handler.
@@ -124,8 +214,7 @@
 
 2007-06-06  Chong Yidong  <cyd@stupidchicken.com>
 
-        * image.c (xpm_load): Remove spurious call to
-        xpm_init_color_cache.
+        * image.c (xpm_load): Remove spurious call to xpm_init_color_cache.
 
 2007-06-06  YAMAMOTO Mitsuharu  <mituharu@math.s.chiba-u.ac.jp>
 
diff --git a/src/composite.c b/src/composite.c
index 3e0606e9007..b0a5ebbc3ee 100644
--- a/src/composite.c
+++ b/src/composite.c
@@ -500,7 +500,8 @@ update_compositions (from, to, check_mask)
          avoid it, in such a case, we change the property of the
          latter to the copy of it.  */
       if (from > BEGV
-          && find_composition (from - 1, -1, &start, &end, &prop, Qnil))
+          && find_composition (from - 1, -1, &start, &end, &prop, Qnil)
+          && COMPOSITION_VALID_P (start, end, prop))
         {
           if (from < end)
             Fput_text_property (make_number (from), make_number (end),
@@ -510,7 +511,8 @@ update_compositions (from, to, check_mask)
           from = end;
         }
       else if (from < ZV
-               && find_composition (from, -1, &start, &from, &prop, Qnil))
+               && find_composition (from, -1, &start, &from, &prop, Qnil)
+               && COMPOSITION_VALID_P (start, from, prop))
         run_composition_function (start, from, prop);
     }
 
@@ -521,6 +523,7 @@ update_compositions (from, to, check_mask)
          (to - 1).  */
       while (from < to - 1
              && find_composition (from, to, &start, &from, &prop, Qnil)
+             && COMPOSITION_VALID_P (start, from, prop)
              && from < to - 1)
         run_composition_function (start, from, prop);
     }
@@ -528,7 +531,8 @@ update_compositions (from, to, check_mask)
   if (check_mask & CHECK_TAIL)
     {
       if (from < to
-          && find_composition (to - 1, -1, &start, &end, &prop, Qnil))
+          && find_composition (to - 1, -1, &start, &end, &prop, Qnil)
+          && COMPOSITION_VALID_P (start, end, prop))
         {
           /* TO should be also at composition boundary.  But,
              insertion or deletion will make two compositions adjacent
@@ -542,7 +546,8 @@ update_compositions (from, to, check_mask)
           run_composition_function (start, end, prop);
         }
       else if (to < ZV
-               && find_composition (to, -1, &start, &end, &prop, Qnil))
+               && find_composition (to, -1, &start, &end, &prop, Qnil)
+               && COMPOSITION_VALID_P (start, end, prop))
         run_composition_function (start, end, prop);
     }
 }
diff --git a/src/config.in b/src/config.in
index f57e889cc44..2b7b5503dcb 100644
--- a/src/config.in
+++ b/src/config.in
@@ -228,7 +228,8 @@ Boston, MA 02110-1301, USA.  */
 /* 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). */
+/* Define to 1 if you have a gif library (default -lungif; otherwise specify
+   with LIBGIF). */
 #undef HAVE_GIF
 
 /* Define to 1 if you have the gpm library (-lgpm). */
@@ -768,6 +769,9 @@ Boston, MA 02110-1301, USA.  */
    Solaris, for example). */
 #undef LD_SWITCH_X_SITE_AUX
 
+/* Compiler option to link with the gif library (if not -lungif). */
+#undef LIBGIF
+
 /* Define to 1 if localtime caches TZ. */
 #undef LOCALTIME_CACHE
 
diff --git a/src/dispextern.h b/src/dispextern.h
index 4c3bd56e121..09dfa0f74d9 100644
--- a/src/dispextern.h
+++ b/src/dispextern.h
@@ -2422,6 +2422,10 @@ struct image
      if necessary.  */
   unsigned long background;
 
+  /* Foreground and background colors of the frame on which the image
+     is created.  */
+  unsigned long frame_foreground, frame_background;
+
   /* True if this image has a `transparent' background -- that is, is
      uses an image mask.  The accessor macro for this is
      `IMAGE_BACKGROUND_TRANSPARENT'.  */
diff --git a/src/editfns.c b/src/editfns.c
index aca3383943d..5fd40ed51c7 100644
--- a/src/editfns.c
+++ b/src/editfns.c
@@ -84,6 +84,11 @@ extern char **environ;
 
 extern size_t emacs_strftimeu P_ ((char *, size_t, const char *,
                                    const struct tm *, int));
+
+#ifdef WINDOWSNT
+extern Lisp_Object w32_get_internal_run_time ();
+#endif
+
 static int tm_diff P_ ((struct tm *, struct tm *));
 static void find_field P_ ((Lisp_Object, Lisp_Object, Lisp_Object, int *, Lisp_Object, int *));
 static void update_buffer_properties P_ ((int, int));
@@ -1483,9 +1488,13 @@ on systems that do not provide resolution finer than a second.  */)
   return list3 (make_number ((secs >> 16) & 0xffff),
                 make_number ((secs >> 0)  & 0xffff),
                 make_number (usecs));
-#else
+#else /* ! HAVE_GETRUSAGE  */
+#if WINDOWSNT
+  return w32_get_internal_run_time ();
+#else /* ! WINDOWSNT  */
   return Fcurrent_time ();
-#endif
+#endif /* WINDOWSNT  */
+#endif /* HAVE_GETRUSAGE  */
 }
 
 
diff --git a/src/frame.h b/src/frame.h
index 47f7483994e..5686662bb96 100644
--- a/src/frame.h
+++ b/src/frame.h
@@ -197,7 +197,7 @@ struct frame
      be used for output.  */
   unsigned glyphs_initialized_p : 1;
 
-#if defined (USE_GTK)
+#if defined (USE_GTK) || defined (MAC_OS)
   /* Nonzero means using a tool bar that comes from the toolkit.  */
   int external_tool_bar;
 #endif
@@ -534,7 +534,7 @@ typedef struct frame *FRAME_PTR;
 
 /* Nonzero if this frame should display a tool bar
    in a way that does not use any text lines.  */
-#if defined (USE_GTK)
+#if defined (USE_GTK) || defined (MAC_OS)
 #define FRAME_EXTERNAL_TOOL_BAR(f) (f)->external_tool_bar
 #else
 #define FRAME_EXTERNAL_TOOL_BAR(f) 0
diff --git a/src/image.c b/src/image.c
index b53fe01d7f9..322689c8d0f 100644
--- a/src/image.c
+++ b/src/image.c
@@ -1642,22 +1642,28 @@ search_image_cache (f, spec, hash)
 {
   struct image *img;
   struct image_cache *c = FRAME_X_IMAGE_CACHE (f);
-  Lisp_Object specified_bg = image_spec_value (spec, QCbackground, NULL);
   int i = hash % IMAGE_CACHE_BUCKETS_SIZE;
 
   /* If the image spec does not specify a background color, the cached
      image must have the same background color as the current frame.
-     The following code be improved.  For example, jpeg does not
-     support transparency, but currently a jpeg image spec won't match
-     a cached spec created with a different frame background.  The
-     extra memory usage is probably negligible in practice.  */
+     The foreground color must also match, for the sake of monochrome
+     images.
+
+     In fact, we could ignore the foreground color matching condition
+     for color images, or if the image spec specifies :foreground;
+     similarly we could ignore the background color matching condition
+     for formats that don't use transparency (such as jpeg), or if the
+     image spec specifies :background.  However, the extra memory
+     usage is probably negligible in practice, so we don't bother.  */
   if (!c) return NULL;
 
   for (img = c->buckets[i]; img; img = img->next)
     if (img->hash == hash
         && !NILP (Fequal (img->spec, spec))
-        && (STRINGP (specified_bg)
-            || img->background == FRAME_BACKGROUND_PIXEL (f)))
+        /* If the image spec specifies a background, it doesn't matter
+           what the frame background is.  */
+        && img->frame_foreground == FRAME_FOREGROUND_PIXEL (f)
+        && img->frame_background == FRAME_BACKGROUND_PIXEL (f))
       break;
   return img;
 }
@@ -1932,6 +1938,8 @@ lookup_image (f, spec)
       img = make_image (spec, hash);
       cache_image (f, img);
       img->load_failed_p = img->type->load (f, img) == 0;
+      img->frame_foreground = FRAME_FOREGROUND_PIXEL (f);
+      img->frame_background = FRAME_BACKGROUND_PIXEL (f);
 
       /* If we can't load the image, and we don't have a width and
          height, use some arbitrary width and height so that we can
diff --git a/src/macfns.c b/src/macfns.c
index cd02552df7a..a58c9975f45 100644
--- a/src/macfns.c
+++ b/src/macfns.c
@@ -1681,6 +1681,25 @@ x_set_tool_bar_lines (f, value, oldval)
   /* Make sure we redisplay all windows in this frame.  */
   ++windows_or_buffers_changed;
 
+#if USE_MAC_TOOLBAR
+  FRAME_TOOL_BAR_LINES (f) = 0;
+  if (nlines)
+    {
+      FRAME_EXTERNAL_TOOL_BAR (f) = 1;
+      if (FRAME_MAC_P (f) && !IsWindowToolbarVisible (FRAME_MAC_WINDOW (f)))
+        /* Make sure next redisplay shows the tool bar.  */
+        XWINDOW (FRAME_SELECTED_WINDOW (f))->update_mode_line = Qt;
+    }
+  else
+    {
+      if (FRAME_EXTERNAL_TOOL_BAR (f))
+        free_frame_tool_bar (f);
+      FRAME_EXTERNAL_TOOL_BAR (f) = 0;
+    }
+
+  return;
+#endif
+
   delta = nlines - FRAME_TOOL_BAR_LINES (f);
 
   /* Don't resize the tool-bar to more than we have room for.  */
@@ -2283,6 +2302,16 @@ mac_window (f, window_prompting, minibuffer_only)
     XSetWindowBackground (FRAME_MAC_DISPLAY(f), FRAME_MAC_WINDOW (f),
                           FRAME_BACKGROUND_PIXEL (f));
 
+#if USE_MAC_TOOLBAR
+  /* At the moment, the size of the tool bar is not yet known.  We
+     record the gravity value of the newly created window and use it
+     to adjust the position of the window (especially for a negative
+     specification of its vertical position) when the tool bar is
+     first redisplayed.  */
+  if (FRAME_EXTERNAL_TOOL_BAR (f))
+    f->output_data.mac->toolbar_win_gravity = f->win_gravity;
+#endif
+
   validate_x_resource_name ();
 
   /* x_set_name normally ignores requests to set the name if the
diff --git a/src/macgui.h b/src/macgui.h
index 990765593e1..fb6f858c547 100644
--- a/src/macgui.h
+++ b/src/macgui.h
@@ -117,6 +117,13 @@ typedef unsigned long Time;
 #endif
 #endif
 
+/* Whether to use HIToolbar.  */
+#ifndef USE_MAC_TOOLBAR
+#if MAC_OS_X_VERSION_MAX_ALLOWED >= 1030 && MAC_OS_X_VERSION_MIN_REQUIRED != 1020
+#define USE_MAC_TOOLBAR 1
+#endif
+#endif
+
 typedef WindowRef Window;
 typedef GWorldPtr Pixmap;
 
diff --git a/src/macmenu.c b/src/macmenu.c
index 1eb0b16cd95..c10a76f8a5d 100644
--- a/src/macmenu.c
+++ b/src/macmenu.c
@@ -1602,6 +1602,10 @@ menu_target_item_handler (next_handler, event, data)
   GrafPtr port;
   int specpdl_count = SPECPDL_INDEX ();
 
+  /* Don't be bothered with the overflowed toolbar items menu.  */
+  if (!popup_activated ())
+    return eventNotHandledErr;
+
   err = GetEventParameter (event, kEventParamDirectObject, typeMenuRef,
                            NULL, sizeof (MenuRef), NULL, &menu);
   if (err == noErr)
diff --git a/src/macterm.c b/src/macterm.c
index f8c79d1c865..9ea51f87cfb 100644
--- a/src/macterm.c
+++ b/src/macterm.c
@@ -2197,6 +2197,57 @@ x_draw_fringe_bitmap (w, row, p)
   struct face *face = p->face;
   int rowY;
 
+#ifdef MAC_OSX
+  if (p->bx >= 0 && !p->overlay_p)
+    {
+      int bx = p->bx, nx = p->nx;
+
+#if 0  /* MAC_TODO: stipple */
+      /* In case the same realized face is used for fringes and
+         for something displayed in the text (e.g. face `region' on
+         mono-displays, the fill style may have been changed to
+         FillSolid in x_draw_glyph_string_background.  */
+      if (face->stipple)
+        XSetFillStyle (FRAME_X_DISPLAY (f), face->gc, FillOpaqueStippled);
+      else
+        XSetForeground (FRAME_X_DISPLAY (f), face->gc, face->background);
+#endif
+
+      /* If the fringe is adjacent to the left (right) scroll bar of a
+         leftmost (rightmost, respectively) window, then extend its
+         background to the gap between the fringe and the bar.  */
+      if ((WINDOW_LEFTMOST_P (w)
+           && WINDOW_HAS_VERTICAL_SCROLL_BAR_ON_LEFT (w))
+          || (WINDOW_RIGHTMOST_P (w)
+              && WINDOW_HAS_VERTICAL_SCROLL_BAR_ON_RIGHT (w)))
+        {
+          int sb_width = WINDOW_CONFIG_SCROLL_BAR_WIDTH (w);
+
+          if (sb_width > 0)
+            {
+              int left = WINDOW_SCROLL_BAR_AREA_X (w);
+              int width = (WINDOW_CONFIG_SCROLL_BAR_COLS (w)
+                           * FRAME_COLUMN_WIDTH (f));
+
+              if (left + width == bx)
+                {
+                  bx = left + sb_width;
+                  nx += width - sb_width;
+                }
+              else if (bx + nx == left)
+                nx += width - sb_width;
+            }
+        }
+
+      mac_erase_rectangle (f, face->gc, bx, p->by, nx, p->ny);
+
+#if 0  /* MAC_TODO: stipple */
+      if (!face->stipple)
+        XSetForeground (FRAME_X_DISPLAY (f), face->gc, face->foreground);
+#endif
+    }
+#endif  /* MAC_OSX */
+
   /* Must clip because of partially visible lines.  */
   rowY = WINDOW_TO_FRAME_PIXEL_Y (w, row->y);
   if (p->y < rowY)
@@ -2214,6 +2265,7 @@ x_draw_fringe_bitmap (w, row, p)
   else
     x_clip_to_row (w, row, -1, face->gc);
 
+#ifndef MAC_OSX
   if (p->bx >= 0 && !p->overlay_p)
     {
 #if 0  /* MAC_TODO: stipple */
@@ -2234,6 +2286,7 @@ x_draw_fringe_bitmap (w, row, p)
         XSetForeground (FRAME_X_DISPLAY (f), face->gc, face->foreground);
 #endif
     }
+#endif  /* !MAC_OSX */
 
   if (p->which
 #if USE_CG_DRAWING
@@ -4990,6 +5043,9 @@ x_scroll_bar_create (w, top, left, width, height, disp_top, disp_height)
   XSETINT (bar->start, 0);
   XSETINT (bar->end, 0);
   bar->dragging = Qnil;
+#ifdef MAC_OSX
+  bar->fringe_extended_p = Qnil;
+#endif
 #ifdef USE_TOOLKIT_SCROLL_BARS
   bar->track_top = Qnil;
   bar->track_height = Qnil;
@@ -5122,6 +5178,9 @@ XTset_vertical_scroll_bar (w, portion, whole, position)
   struct scroll_bar *bar;
   int top, height, left, sb_left, width, sb_width, disp_top, disp_height;
   int window_y, window_height;
+#ifdef MAC_OSX
+  int fringe_extended_p;
+#endif
 
   /* Get window dimensions.  */
   window_box (w, -1, 0, &window_y, 0, &window_height);
@@ -5141,9 +5200,9 @@ XTset_vertical_scroll_bar (w, portion, whole, position)
 
   /* Compute the left edge of the scroll bar.  */
   if (WINDOW_HAS_VERTICAL_SCROLL_BAR_ON_RIGHT (w))
-    sb_left = left;
+    sb_left = left + (WINDOW_RIGHTMOST_P (w) ? width - sb_width : 0);
   else
-    sb_left = left + width - sb_width;
+    sb_left = left + (WINDOW_LEFTMOST_P (w) ? 0 : width - sb_width);
 
   /* Adjustments according to Inside Macintosh to make it look nice */
   disp_top = top;
@@ -5164,11 +5223,29 @@ XTset_vertical_scroll_bar (w, portion, whole, position)
     sb_left++;
 #endif
 
+#ifdef MAC_OSX
+  if (WINDOW_HAS_VERTICAL_SCROLL_BAR_ON_LEFT (w))
+    fringe_extended_p = (WINDOW_LEFTMOST_P (w)
+                         && WINDOW_LEFT_FRINGE_WIDTH (w)
+                         && (WINDOW_HAS_FRINGES_OUTSIDE_MARGINS (w)
+                             || WINDOW_LEFT_MARGIN_COLS (w) == 0));
+  else
+    fringe_extended_p = (WINDOW_RIGHTMOST_P (w)
+                         && WINDOW_RIGHT_FRINGE_WIDTH (w)
+                         && (WINDOW_HAS_FRINGES_OUTSIDE_MARGINS (w)
+                             || WINDOW_RIGHT_MARGIN_COLS (w) == 0));
+#endif
+
   /* Does the scroll bar exist yet?  */
   if (NILP (w->vertical_scroll_bar))
     {
       BLOCK_INPUT;
-      mac_clear_area (f, left, top, width, height);
+#ifdef MAC_OSX
+      if (fringe_extended_p)
+        mac_clear_area (f, sb_left, top, sb_width, height);
+      else
+#endif
+        mac_clear_area (f, left, top, width, height);
       UNBLOCK_INPUT;
       bar = x_scroll_bar_create (w, top, sb_left, sb_width, height, disp_top,
                                  disp_height);
@@ -5188,11 +5265,20 @@ XTset_vertical_scroll_bar (w, portion, whole, position)
       if (!(XINT (bar->left) == sb_left
             && XINT (bar->top) == top
             && XINT (bar->width) == sb_width
-            && XINT (bar->height) == height))
+            && XINT (bar->height) == height
+#ifdef MAC_OSX
+            && !NILP (bar->fringe_extended_p) == fringe_extended_p
+#endif
+            ))
         {
           /* Since toolkit scroll bars are smaller than the space reserved
              for them on the frame, we have to clear "under" them.  */
-          mac_clear_area (f, left, top, width, height);
+#ifdef MAC_OSX
+          if (fringe_extended_p)
+            mac_clear_area (f, sb_left, top, sb_width, height);
+          else
+#endif
+            mac_clear_area (f, left, top, width, height);
 
 #if USE_CG_DRAWING
           mac_prepare_for_quickdraw (f);
@@ -5221,6 +5307,10 @@ XTset_vertical_scroll_bar (w, portion, whole, position)
       UNBLOCK_INPUT;
     }
 
+#ifdef MAC_OSX
+  bar->fringe_extended_p = fringe_extended_p ? Qt : Qnil;
+#endif
+
 #ifdef USE_TOOLKIT_SCROLL_BARS
   if (NILP (bar->track_top))
     {
@@ -5584,6 +5674,539 @@ x_scroll_bar_clear (f)
 
 
 /***********************************************************************
+                               Tool-bars
+ ***********************************************************************/
+#if USE_MAC_TOOLBAR
+
+/* In identifiers such as function/variable names, Emacs tool bar is
+   referred to as `tool_bar', and Carbon HIToolbar as `toolbar'.  */
+
+#define TOOLBAR_IDENTIFIER (CFSTR ("org.gnu.Emacs.toolbar"))
+#define TOOLBAR_ICON_ITEM_IDENTIFIER (CFSTR ("org.gnu.Emacs.toolbar.icon"))
+
+#define TOOLBAR_ITEM_COMMAND_ID_OFFSET 'Tb\0\0'
+#define TOOLBAR_ITEM_COMMAND_ID_P(id)                   \
+  (((id) & ~0xffff) == TOOLBAR_ITEM_COMMAND_ID_OFFSET)
+#define TOOLBAR_ITEM_COMMAND_ID_VALUE(id)       \
+  ((id) - TOOLBAR_ITEM_COMMAND_ID_OFFSET)
+#define TOOLBAR_ITEM_MAKE_COMMAND_ID(value)     \
+  ((value) + TOOLBAR_ITEM_COMMAND_ID_OFFSET)
+
+static int mac_event_to_emacs_modifiers P_ ((EventRef));
+static void mac_handle_origin_change P_ ((struct frame *));
+static OSStatus mac_handle_toolbar_command_event P_ ((EventHandlerCallRef,
+                                                      EventRef, void *));
+
+static void
+mac_move_window_with_gravity (f, win_gravity, left, top)
+     struct frame *f;
+     int win_gravity;
+     short left, top;
+{
+  Rect inner, outer;
+
+  mac_get_window_bounds (f, &inner, &outer);
+
+  switch (win_gravity)
+    {
+    case NorthWestGravity:
+    case WestGravity:
+    case SouthWestGravity:
+      left += inner.left - outer.left;
+      break;
+
+    case NorthGravity:
+    case CenterGravity:
+    case SouthGravity:
+      left += ((inner.left - outer.left) + (inner.right - outer.right)) / 2;
+      break;
+
+    case NorthEastGravity:
+    case EastGravity:
+    case SouthEastGravity:
+      left += inner.right - outer.right;
+      break;
+    }
+
+  switch (win_gravity)
+    {
+    case NorthWestGravity:
+    case NorthGravity:
+    case NorthEastGravity:
+      top += inner.top - outer.top;
+      break;
+
+    case WestGravity:
+    case CenterGravity:
+    case EastGravity:
+      top += ((inner.top - outer.top) + (inner.bottom - outer.bottom)) / 2;
+      break;
+
+    case SouthWestGravity:
+    case SouthGravity:
+    case SouthEastGravity:
+      top += inner.bottom - outer.bottom;
+      break;
+    }
+
+  MoveWindow (FRAME_MAC_WINDOW (f), left, top, false);
+}
+
+static void
+mac_get_window_origin_with_gravity (f, win_gravity, left, top)
+     struct frame *f;
+     int win_gravity;
+     short *left, *top;
+{
+  Rect inner, outer;
+
+  mac_get_window_bounds (f, &inner, &outer);
+
+  switch (win_gravity)
+    {
+    case NorthWestGravity:
+    case WestGravity:
+    case SouthWestGravity:
+      *left = outer.left;
+      break;
+
+    case NorthGravity:
+    case CenterGravity:
+    case SouthGravity:
+      *left = outer.left + ((outer.right - outer.left)
+                            - (inner.right - inner.left)) / 2;
+      break;
+
+    case NorthEastGravity:
+    case EastGravity:
+    case SouthEastGravity:
+      *left = outer.right - (inner.right - inner.left);
+      break;
+    }
+
+  switch (win_gravity)
+    {
+    case NorthWestGravity:
+    case NorthGravity:
+    case NorthEastGravity:
+      *top = outer.top;
+      break;
+
+    case WestGravity:
+    case CenterGravity:
+    case EastGravity:
+      *top = outer.top + ((outer.bottom - outer.top)
+                          - (inner.bottom - inner.top)) / 2;
+      break;
+
+    case SouthWestGravity:
+    case SouthGravity:
+    case SouthEastGravity:
+      *top = outer.bottom - (inner.bottom - inner.top);
+      break;
+    }
+}
+
+static OSStatus
+mac_handle_toolbar_event (next_handler, event, data)
+     EventHandlerCallRef next_handler;
+     EventRef event;
+     void *data;
+{
+  OSStatus err, result = eventNotHandledErr;
+
+  switch (GetEventKind (event))
+    {
+    case kEventToolbarGetDefaultIdentifiers:
+      result = noErr;
+      break;
+
+    case kEventToolbarGetAllowedIdentifiers:
+      {
+        CFMutableArrayRef array;
+
+        GetEventParameter (event, kEventParamMutableArray,
+                           typeCFMutableArrayRef, NULL,
+                           sizeof (CFMutableArrayRef), NULL, &array);
+        CFArrayAppendValue (array, TOOLBAR_ICON_ITEM_IDENTIFIER);
+        result = noErr;
+      }
+      break;
+
+    case kEventToolbarCreateItemWithIdentifier:
+      {
+        CFStringRef identifier;
+        HIToolbarItemRef item = NULL;
+
+        GetEventParameter (event, kEventParamToolbarItemIdentifier,
+                           typeCFStringRef, NULL,
+                           sizeof (CFStringRef), NULL, &identifier);
+
+        if (CFStringCompare (identifier, TOOLBAR_ICON_ITEM_IDENTIFIER, 0)
+            == kCFCompareEqualTo)
+          HIToolbarItemCreate (identifier,
+                               kHIToolbarItemAllowDuplicates
+                               | kHIToolbarItemCantBeRemoved, &item);
+
+        if (item)
+          {
+            SetEventParameter (event, kEventParamToolbarItem,
+                               typeHIToolbarItemRef,
+                               sizeof (HIToolbarItemRef), &item);
+            result = noErr;
+          }
+      }
+      break;
+
+    default:
+      abort ();
+    }
+
+  return result;
+}
+
+static CGImageRef
+mac_image_spec_to_cg_image (f, image)
+     struct frame *f;
+     Lisp_Object image;
+{
+  if (!valid_image_p (image))
+    return NULL;
+  else
+    {
+      int img_id = lookup_image (f, image);
+      struct image *img = IMAGE_FROM_ID (f, img_id);
+
+      prepare_image_for_display (f, img);
+
+      return img->data.ptr_val;
+    }
+}
+
+/* Create a tool bar for frame F.  */
+
+static OSStatus
+mac_create_frame_tool_bar (f)
+     FRAME_PTR f;
+{
+  OSStatus err;
+  HIToolbarRef toolbar;
+
+  err = HIToolbarCreate (TOOLBAR_IDENTIFIER, kHIToolbarNoAttributes,
+                         &toolbar);
+  if (err == noErr)
+    {
+      static const EventTypeSpec specs[] =
+        {{kEventClassToolbar, kEventToolbarGetDefaultIdentifiers},
+         {kEventClassToolbar, kEventToolbarGetAllowedIdentifiers},
+         {kEventClassToolbar, kEventToolbarCreateItemWithIdentifier}};
+
+      err = InstallEventHandler (HIObjectGetEventTarget (toolbar),
+                                 mac_handle_toolbar_event,
+                                 GetEventTypeCount (specs), specs,
+                                 f, NULL);
+    }
+
+  if (err == noErr)
+    err = HIToolbarSetDisplayMode (toolbar, kHIToolbarDisplayModeIconOnly);
+  if (err == noErr)
+    {
+      static const EventTypeSpec specs[] =
+        {{kEventClassCommand, kEventCommandProcess}};
+
+      err = InstallWindowEventHandler (FRAME_MAC_WINDOW (f),
+                                       mac_handle_toolbar_command_event,
+                                       GetEventTypeCount (specs),
+                                       specs, f, NULL);
+    }
+  if (err == noErr)
+    err = SetWindowToolbar (FRAME_MAC_WINDOW (f), toolbar);
+
+  if (toolbar)
+    CFRelease (toolbar);
+
+  return err;
+}
+
+/* Update the tool bar for frame F.  Add new buttons and remove old.  */
+
+void
+update_frame_tool_bar (f)
+     FRAME_PTR f;
+{
+  HIToolbarRef toolbar = NULL;
+  short left, top;
+  CFArrayRef old_items = NULL;
+  CFIndex old_count;
+  int i, pos, win_gravity = f->output_data.mac->toolbar_win_gravity;
+  struct mac_display_info *dpyinfo = FRAME_MAC_DISPLAY_INFO (f);
+
+  BLOCK_INPUT;
+
+  GetWindowToolbar (FRAME_MAC_WINDOW (f), &toolbar);
+  if (toolbar == NULL)
+    {
+      mac_create_frame_tool_bar (f);
+      GetWindowToolbar (FRAME_MAC_WINDOW (f), &toolbar);
+      if (toolbar == NULL)
+        goto out;
+      if (win_gravity >= NorthWestGravity && win_gravity <= SouthEastGravity)
+        mac_get_window_origin_with_gravity (f, win_gravity, &left, &top);
+    }
+
+  HIToolbarCopyItems (toolbar, &old_items);
+  if (old_items == NULL)
+    goto out;
+
+  old_count = CFArrayGetCount (old_items);
+  pos = 0;
+  for (i = 0; i < f->n_tool_bar_items; ++i)
+    {
+#define PROP(IDX) AREF (f->tool_bar_items, i * TOOL_BAR_ITEM_NSLOTS + (IDX))
+
+      int enabled_p = !NILP (PROP (TOOL_BAR_ITEM_ENABLED_P));
+      int selected_p = !NILP (PROP (TOOL_BAR_ITEM_SELECTED_P));
+      int idx;
+      Lisp_Object image;
+      CGImageRef cg_image;
+      CFStringRef label;
+      HIToolbarItemRef item;
+
+      /* If image is a vector, choose the image according to the
+         button state.  */
+      image = PROP (TOOL_BAR_ITEM_IMAGES);
+      if (VECTORP (image))
+        {
+          if (enabled_p)
+            idx = (selected_p
+                   ? TOOL_BAR_IMAGE_ENABLED_SELECTED
+                   : TOOL_BAR_IMAGE_ENABLED_DESELECTED);
+          else
+            idx = (selected_p
+                   ? TOOL_BAR_IMAGE_DISABLED_SELECTED
+                   : TOOL_BAR_IMAGE_DISABLED_DESELECTED);
+
+          xassert (ASIZE (image) >= idx);
+          image = AREF (image, idx);
+        }
+      else
+        idx = -1;
+
+      cg_image = mac_image_spec_to_cg_image (f, image);
+      /* Ignore invalid image specifications.  */
+      if (cg_image == NULL)
+        continue;
+
+      label = cfstring_create_with_string (PROP (TOOL_BAR_ITEM_CAPTION));
+      if (label == NULL)
+        label = CFSTR ("");
+
+      if (pos < old_count)
+        {
+          CGImageRef old_cg_image = NULL;
+          CFStringRef old_label = NULL;
+          Boolean old_enabled_p;
+
+          item = (HIToolbarItemRef) CFArrayGetValueAtIndex (old_items, pos);
+
+          HIToolbarItemCopyImage (item, &old_cg_image);
+          if (cg_image != old_cg_image)
+            HIToolbarItemSetImage (item, cg_image);
+          CGImageRelease (old_cg_image);
+
+          HIToolbarItemCopyLabel (item, &old_label);
+          if (CFStringCompare (label, old_label, 0) != kCFCompareEqualTo)
+            HIToolbarItemSetLabel (item, label);
+          CFRelease (old_label);
+
+          old_enabled_p = HIToolbarItemIsEnabled (item);
+          if ((enabled_p || idx >= 0) != old_enabled_p)
+            HIToolbarItemSetEnabled (item, (enabled_p || idx >= 0));
+        }
+      else
+        {
+          item = NULL;
+          HIToolbarCreateItemWithIdentifier (toolbar,
+                                             TOOLBAR_ICON_ITEM_IDENTIFIER,
+                                             NULL, &item);
+          if (item)
+            {
+              HIToolbarItemSetImage (item, cg_image);
+              HIToolbarItemSetLabel (item, label);
+              HIToolbarItemSetEnabled (item, (enabled_p || idx >= 0));
+              HIToolbarAppendItem (toolbar, item);
+              CFRelease (item);
+            }
+        }
+
+      CFRelease (label);
+      if (item)
+        {
+          HIToolbarItemSetCommandID (item, TOOLBAR_ITEM_MAKE_COMMAND_ID (i));
+          pos++;
+        }
+    }
+
+  CFRelease (old_items);
+
+  while (pos < old_count)
+    HIToolbarRemoveItemAtIndex (toolbar, --old_count);
+
+  ShowHideWindowToolbar (FRAME_MAC_WINDOW (f), true,
+                         !win_gravity && f == mac_focus_frame (dpyinfo));
+  /* Mac OS X 10.3 does not issue kEventWindowBoundsChanged events on
+     toolbar visibility change.  */
+  mac_handle_origin_change (f);
+  if (win_gravity >= NorthWestGravity && win_gravity <= SouthEastGravity)
+    {
+      mac_move_window_with_gravity (f, win_gravity, left, top);
+      /* If the title bar is completely outside the screen, adjust the
+         position. */
+      ConstrainWindowToScreen (FRAME_MAC_WINDOW (f), kWindowTitleBarRgn,
+                               kWindowConstrainMoveRegardlessOfFit
+                               | kWindowConstrainAllowPartial, NULL, NULL);
+      f->output_data.mac->toolbar_win_gravity = 0;
+    }
+
+ out:
+  UNBLOCK_INPUT;
+}
+
+/* Hide the tool bar on frame F.  Unlike the counterpart on GTK+, it
+   doesn't deallocate the resources.  */
+
+void
+free_frame_tool_bar (f)
+     FRAME_PTR f;
+{
+  if (IsWindowToolbarVisible (FRAME_MAC_WINDOW (f)))
+    {
+      struct mac_display_info *dpyinfo = FRAME_MAC_DISPLAY_INFO (f);
+
+      BLOCK_INPUT;
+      ShowHideWindowToolbar (FRAME_MAC_WINDOW (f), false,
+                             f == mac_focus_frame (dpyinfo));
+      /* Mac OS X 10.3 does not issue kEventWindowBoundsChanged events
+         on toolbar visibility change.  */
+      mac_handle_origin_change (f);
+      UNBLOCK_INPUT;
+    }
+}
+
+static void
+mac_tool_bar_note_mouse_movement (f, event)
+     struct frame *f;
+     EventRef event;
+{
+  OSStatus err;
+  struct mac_display_info *dpyinfo = FRAME_MAC_DISPLAY_INFO (f);
+  int mouse_down_p;
+  HIViewRef item_view;
+  UInt32 command_id;
+
+  mouse_down_p = (dpyinfo->grabbed
+                  && f == last_mouse_frame
+                  && FRAME_LIVE_P (f));
+  if (mouse_down_p)
+    return;
+
+  err = HIViewGetViewForMouseEvent (HIViewGetRoot (FRAME_MAC_WINDOW (f)),
+                                    event, &item_view);
+  /* This doesn't work on Mac OS X 10.2.  On Mac OS X 10.3 and 10.4, a
+     toolbar item view seems to have the same command ID with that of
+     the toolbar item.  */
+  if (err == noErr)
+    err = GetControlCommandID (item_view, &command_id);
+  if (err == noErr && TOOLBAR_ITEM_COMMAND_ID_P (command_id))
+    {
+      int i = TOOLBAR_ITEM_COMMAND_ID_VALUE (command_id);
+
+      if (i < f->n_tool_bar_items)
+        {
+          HIRect bounds;
+          HIViewRef content_view;
+
+          err = HIViewGetBounds (item_view, &bounds);
+          if (err == noErr)
+            err = HIViewFindByID (HIViewGetRoot (FRAME_MAC_WINDOW (f)),
+                                  kHIViewWindowContentID, &content_view);
+          if (err == noErr)
+            err = HIViewConvertRect (&bounds, item_view, content_view);
+          if (err == noErr)
+            SetRect (&last_mouse_glyph,
+                     CGRectGetMinX (bounds), CGRectGetMinY (bounds),
+                     CGRectGetMaxX (bounds), CGRectGetMaxY (bounds));
+
+          help_echo_object = help_echo_window = Qnil;
+          help_echo_pos = -1;
+          help_echo_string = PROP (TOOL_BAR_ITEM_HELP);
+          if (NILP (help_echo_string))
+            help_echo_string = PROP (TOOL_BAR_ITEM_CAPTION);
+        }
+    }
+}
+
+static OSStatus
+mac_handle_toolbar_command_event (next_handler, event, data)
+     EventHandlerCallRef next_handler;
+     EventRef event;
+     void *data;
+{
+  OSStatus err, result = eventNotHandledErr;
+  struct frame *f = (struct frame *) data;
+  HICommand command;
+
+  err = GetEventParameter (event, kEventParamDirectObject,
+                           typeHICommand, NULL,
+                           sizeof (HICommand), NULL, &command);
+  if (err != noErr)
+    return result;
+
+  switch (GetEventKind (event))
+    {
+    case kEventCommandProcess:
+      if (!TOOLBAR_ITEM_COMMAND_ID_P (command.commandID))
+        result = CallNextEventHandler (next_handler, event);
+      else
+        {
+          int i = TOOLBAR_ITEM_COMMAND_ID_VALUE (command.commandID);
+
+          if (i < f->n_tool_bar_items
+              && !NILP (PROP (TOOL_BAR_ITEM_ENABLED_P)))
+            {
+              Lisp_Object frame;
+              struct input_event buf;
+
+              EVENT_INIT (buf);
+
+              XSETFRAME (frame, f);
+              buf.kind = TOOL_BAR_EVENT;
+              buf.frame_or_window = frame;
+              buf.arg = frame;
+              kbd_buffer_store_event (&buf);
+
+              buf.kind = TOOL_BAR_EVENT;
+              buf.frame_or_window = frame;
+              buf.arg = PROP (TOOL_BAR_ITEM_KEY);
+              buf.modifiers = mac_event_to_emacs_modifiers (event);
+              kbd_buffer_store_event (&buf);
+
+              result = noErr;
+            }
+        }
+      break;
+
+    default:
+      abort ();
+    }
+#undef PROP
+
+  return result;
+}
+#endif  /* USE_MAC_TOOLBAR */
+
+
+/***********************************************************************
                              Text Cursor
  ***********************************************************************/
 
@@ -10075,6 +10698,13 @@ mac_handle_window_event (next_handler, event, data)
                                 kWindowCascadeOnParentWindowScreen
 #endif
                                 );
+#if USE_MAC_TOOLBAR
+              /* This is a workaround.  RepositionWindow fails to put
+                 a window at the cascading position when its parent
+                 window has a Carbon HIToolbar.  */
+              if (f->top_pos == sf->top_pos && f->left_pos == sf->left_pos)
+                MoveWindowStructure (wp,  f->left_pos + 10, f->top_pos + 32);
+#endif
             }
           result = noErr;
         }
@@ -10357,8 +10987,7 @@ mac_handle_keyboard_event (next_handler, event, data)
       if (err != noErr)
         break;
 
-      do_keystroke ((GetEventKind (event) == kEventRawKeyDown
-                     ? keyDown : autoKey),
+      do_keystroke ((event_kind == kEventRawKeyDown ? keyDown : autoKey),
                     char_code, key_code, modifiers,
                     ((unsigned long)
                      (GetEventTime (event) / kEventDurationMillisecond)),
@@ -11412,6 +12041,21 @@ XTread_socket (sd, expected, hold_quit)
                   do_zoom_window (window_ptr, part_code);
                 break;
 
+#if USE_MAC_TOOLBAR
+              case inStructure:
+                {
+                  OSStatus err;
+                  HIViewRef ch;
+
+                  err = HIViewGetViewForMouseEvent (HIViewGetRoot (window_ptr),
+                                                    eventRef, &ch);
+                  /* This doesn't work on Mac OS X 10.2.  */
+                  if (err == noErr)
+                    HIViewClick (ch, eventRef);
+                }
+                break;
+#endif  /* USE_MAC_TOOLBAR */
+
               default:
                 break;
               }
@@ -11496,6 +12140,10 @@ XTread_socket (sd, expected, hold_quit)
                         }
                       if (!note_mouse_movement (f, &mouse_pos))
                         help_echo_string = previous_help_echo_string;
+#if USE_MAC_TOOLBAR
+                      else
+                        mac_tool_bar_note_mouse_movement (f, eventRef);
+#endif
                     }
                 }
 
diff --git a/src/macterm.h b/src/macterm.h
index c880143634e..77710b11e71 100644
--- a/src/macterm.h
+++ b/src/macterm.h
@@ -336,6 +336,16 @@ struct mac_output
   /* Hints for the size and the position of a window.  */
   XSizeHints *size_hints;
 
+#if USE_MAC_TOOLBAR
+  /* This variable records the gravity value of the window position if
+     the window has an external tool bar when it is created.  The
+     position of the window is adjusted using this information when
+     the tool bar is first redisplayed.  Once the tool bar is
+     redisplayed, it is set to 0 in order to avoid further
+     adjustment.  */
+  int toolbar_win_gravity;
+#endif
+
 #if USE_CG_DRAWING
   /* Quartz 2D graphics context.  */
   CGContextRef cg_context;
@@ -441,6 +451,12 @@ struct scroll_bar {
      being dragged, this is Qnil.  */
   Lisp_Object dragging;
 
+#ifdef MAC_OSX
+  /* t if the background of the fringe that is adjacent to a scroll
+     bar is extended to the gap between the fringe and the bar.  */
+  Lisp_Object fringe_extended_p;
+#endif
+
 #ifdef USE_TOOLKIT_SCROLL_BARS
   /* The position and size of the scroll bar handle track area in
      pixels, relative to the frame.  */
@@ -651,6 +667,10 @@ extern void mac_prepare_for_quickdraw P_ ((struct frame *));
 #endif
 extern void mac_get_window_bounds P_ ((struct frame *, Rect *, Rect *));
 extern int mac_quit_char_key_p P_ ((UInt32, UInt32));
+#if USE_MAC_TOOLBAR
+extern void update_frame_tool_bar P_ ((FRAME_PTR f));
+extern void free_frame_tool_bar P_ ((FRAME_PTR f));
+#endif
 
 #define FONT_TYPE_FOR_UNIBYTE(font, ch) 0
 #define FONT_TYPE_FOR_MULTIBYTE(font, ch) 0
diff --git a/src/regex.c b/src/regex.c
index 7784a3ae616..1e80b9bbeef 100644
--- a/src/regex.c
+++ b/src/regex.c
@@ -2482,11 +2482,6 @@ regex_compile (pattern, size, syntax, bufp)
      last -- ends with a forward jump of this sort.  */
   unsigned char *fixup_alt_jump = 0;
 
-  /* Counts open-groups as they are encountered.  Remembered for the
-     matching close-group on the compile stack, so the same register
-     number is put in the stop_memory as the start_memory.  */
-  regnum_t regnum = 0;
-
   /* Work area for range table of charset.  */
   struct range_table_work_area range_table_work;
 
@@ -3123,28 +3118,54 @@ regex_compile (pattern, size, syntax, bufp)
             handle_open:
               {
                 int shy = 0;
+                regnum_t regnum = 0;
                 if (p+1 < pend)
                   {
                     /* Look for a special (?...) construct */
                     if ((syntax & RE_SHY_GROUPS) && *p == '?')
                       {
                         PATFETCH (c); /* Gobble up the '?'.  */
-                        PATFETCH (c);
-                        switch (c)
+                        while (!shy)
                           {
-                          case ':': shy = 1; break;
-                          default:
-                            /* Only (?:...) is supported right now. */
-                            FREE_STACK_RETURN (REG_BADPAT);
+                            PATFETCH (c);
+                            switch (c)
+                              {
+                              case ':': shy = 1; break;
+                              case '0':
+                                /* An explicitly specified regnum must start
+                                   with non-0. */
+                                if (regnum == 0)
+                                  FREE_STACK_RETURN (REG_BADPAT);
+                              case '1': case '2': case '3': case '4':
+                              case '5': case '6': case '7': case '8': case '9':
+                                regnum = 10*regnum + (c - '0'); break;
+                              default:
+                                /* Only (?:...) is supported right now. */
+                                FREE_STACK_RETURN (REG_BADPAT);
+                              }
                           }
                       }
                   }
 
                 if (!shy)
-                  {
-                    bufp->re_nsub++;
-                    regnum++;
+                  regnum = ++bufp->re_nsub;
+                else if (regnum)
+                  { /* It's actually not shy, but explicitly numbered.  */
+                    shy = 0;
+                    if (regnum > bufp->re_nsub)
+                      bufp->re_nsub = regnum;
+                    else if (regnum > bufp->re_nsub
+                             /* Ideally, we'd want to check that the specified
+                                group can't have matched (i.e. all subgroups
+                                using the same regnum are in other branches of
+                                OR patterns), but we don't currently keep track
+                                of enough info to do that easily.  */
+                             || group_in_compile_stack (compile_stack, regnum))
+                      FREE_STACK_RETURN (REG_BADPAT);
                   }
+                else
+                  /* It's really shy.  */
+                  regnum = - bufp->re_nsub;
 
                 if (COMPILE_STACK_FULL)
                   {
@@ -3163,12 +3184,11 @@ regex_compile (pattern, size, syntax, bufp)
                 COMPILE_STACK_TOP.fixup_alt_jump
                   = fixup_alt_jump ? fixup_alt_jump - bufp->buffer + 1 : 0;
                 COMPILE_STACK_TOP.laststart_offset = b - bufp->buffer;
-                COMPILE_STACK_TOP.regnum = shy ? -regnum : regnum;
+                COMPILE_STACK_TOP.regnum = regnum;
 
-                /* Do not push a
-                   start_memory for groups beyond the last one we can
-                   represent in the compiled pattern.  */
-                if (regnum <= MAX_REGNUM && !shy)
+                /* Do not push a start_memory for groups beyond the last one
+                   we can represent in the compiled pattern.  */
+                if (regnum <= MAX_REGNUM && regnum > 0)
                   BUF_PUSH_2 (start_memory, regnum);
 
                 compile_stack.avail++;
@@ -3213,7 +3233,7 @@ regex_compile (pattern, size, syntax, bufp)
                 /* We don't just want to restore into `regnum', because
                    later groups should continue to be numbered higher,
                    as in `(ab)c(de)' -- the second group is #2.  */
-                regnum_t this_group_regnum;
+                regnum_t regnum;
 
                 compile_stack.avail--;
                 begalt = bufp->buffer + COMPILE_STACK_TOP.begalt_offset;
@@ -3222,7 +3242,7 @@ regex_compile (pattern, size, syntax, bufp)
                     ? bufp->buffer + COMPILE_STACK_TOP.fixup_alt_jump - 1
                     : 0;
                 laststart = bufp->buffer + COMPILE_STACK_TOP.laststart_offset;
-                this_group_regnum = COMPILE_STACK_TOP.regnum;
+                regnum = COMPILE_STACK_TOP.regnum;
                 /* If we've reached MAX_REGNUM groups, then this open
                    won't actually generate any code, so we'll have to
                    clear pending_exact explicitly.  */
@@ -3230,8 +3250,8 @@ regex_compile (pattern, size, syntax, bufp)
 
                 /* We're at the end of the group, so now we know how many
                    groups were inside this one.  */
-                if (this_group_regnum <= MAX_REGNUM && this_group_regnum > 0)
-                  BUF_PUSH_2 (stop_memory, this_group_regnum);
+                if (regnum <= MAX_REGNUM && regnum > 0)
+                  BUF_PUSH_2 (stop_memory, regnum);
               }
               break;
 
@@ -3557,8 +3577,9 @@ regex_compile (pattern, size, syntax, bufp)
 
                 reg = c - '0';
 
-                /* Can't back reference to a subexpression before its end.  */
-                if (reg > regnum || group_in_compile_stack (compile_stack, reg))
+                if (reg > bufp->re_nsub || reg < 1
+                    /* Can't back reference to a subexp before its end.  */
+                    || group_in_compile_stack (compile_stack, reg))
                   FREE_STACK_RETURN (REG_ESUBREG);
 
                 laststart = b;
diff --git a/src/term.c b/src/term.c
index ceeac103e85..122eab91bdb 100644
--- a/src/term.c
+++ b/src/term.c
@@ -50,6 +50,7 @@ Boston, MA 02110-1301, USA.  */
 #include "blockinput.h"
 #include "syssignal.h"
 #include "systty.h"
+#include "intervals.h"
 
 /* For now, don't try to include termcap.h.  On some systems,
    configure finds a non-standard termcap.h that the main build
diff --git a/src/w32.c b/src/w32.c
index f0258dd6628..0ed462089d6 100644
--- a/src/w32.c
+++ b/src/w32.c
@@ -137,6 +137,15 @@ typedef BOOL (WINAPI * GetTokenInformation_Proc) (
     LPVOID TokenInformation,
     DWORD TokenInformationLength,
     PDWORD ReturnLength);
+typedef BOOL (WINAPI * GetProcessTimes_Proc) (
+    HANDLE process_handle,
+    LPFILETIME creation_time,
+    LPFILETIME exit_time,
+    LPFILETIME kernel_time,
+    LPFILETIME user_time);
+
+GetProcessTimes_Proc get_process_times_fn = NULL;
+
 #ifdef _UNICODE
 const char * const LookupAccountSid_Name = "LookupAccountSidW";
 #else
@@ -172,6 +181,46 @@ is_windows_9x ()
   return s_b_ret;
 }
 
+/* Get total user and system times for get-internal-run-time.
+   Returns a list of three integers if the times are provided by the OS
+   (NT derivatives), otherwise it returns the result of current-time. */
+Lisp_Object
+w32_get_internal_run_time ()
+{
+  if (get_process_times_fn)
+    {
+      FILETIME create, exit, kernel, user;
+      HANDLE proc = GetCurrentProcess();
+      if ((*get_process_times_fn) (proc, &create, &exit, &kernel, &user))
+        {
+          LARGE_INTEGER user_int, kernel_int, total;
+          int microseconds;
+          user_int.LowPart = user.dwLowDateTime;
+          user_int.HighPart = user.dwHighDateTime;
+          kernel_int.LowPart = kernel.dwLowDateTime;
+          kernel_int.HighPart = kernel.dwHighDateTime;
+          total.QuadPart = user_int.QuadPart + kernel_int.QuadPart;
+          /* FILETIME is 100 nanosecond increments, Emacs only wants
+             microsecond resolution.  */
+          total.QuadPart /= 10;
+          microseconds = total.QuadPart % 1000000;
+          total.QuadPart /= 1000000;
+
+          /* Sanity check to make sure we can represent the result.  */
+          if (total.HighPart == 0)
+            {
+              int secs = total.LowPart;
+
+              return list3 (make_number ((secs >> 16) & 0xffff),
+                            make_number (secs & 0xffff),
+                            make_number (microseconds));
+            }
+        }
+    }
+
+  return Fcurrent_time ();
+}
+
   /* ** The wrapper functions ** */
 
 BOOL WINAPI open_process_token (
@@ -486,20 +535,16 @@ init_user_info ()
      the user-sid as the user id value (same for group id using the
      primary group sid from the process token). */
 
-  char            user_sid[256], name[256], domain[256];
-  DWORD           length = sizeof (name), dlength = sizeof (domain), trash;
-  HANDLE          token = NULL;
-  SID_NAME_USE    user_type;
-
-  if (
-                        open_process_token (GetCurrentProcess (), TOKEN_QUERY, &token)
-      && get_token_information (
-                                        token, TokenUser,
-                              (PVOID) user_sid, sizeof (user_sid), &trash)
-      && lookup_account_sid (
-                                        NULL, *((PSID *) user_sid), name, &length,
-                           domain, &dlength, &user_type)
-                        )
+  char         user_sid[256], name[256], domain[256];
+  DWORD        length = sizeof (name), dlength = sizeof (domain), trash;
+  HANDLE       token = NULL;
+  SID_NAME_USE user_type;
+
+  if (open_process_token (GetCurrentProcess (), TOKEN_QUERY, &token)
+      && get_token_information (token, TokenUser,
+                                (PVOID) user_sid, sizeof (user_sid), &trash)
+      && lookup_account_sid (NULL, *((PSID *) user_sid), name, &length,
+                             domain, &dlength, &user_type))
     {
       strcpy (the_passwd.pw_name, name);
       /* Determine a reasonable uid value. */
@@ -524,7 +569,7 @@ init_user_info ()
 
           /* Get group id */
           if (get_token_information (token, TokenPrimaryGroup,
-                                   (PVOID) user_sid, sizeof (user_sid), &trash))
+                                     (PVOID) user_sid, sizeof (user_sid), &trash))
             {
               SID_IDENTIFIER_AUTHORITY * pSIA;
 
@@ -541,7 +586,7 @@ init_user_info ()
         }
     }
   /* If security calls are not supported (presumably because we
-       are running under Windows 95), fallback to this. */
+     are running under Windows 95), fallback to this. */
   else if (GetUserName (name, &length))
     {
       strcpy (the_passwd.pw_name, name);
@@ -4136,6 +4181,11 @@ BOOL WINAPI shutdown_handler(DWORD type)
 void
 globals_of_w32 ()
 {
+  HMODULE kernel32 = GetModuleHandle ("kernel32.dll");
+
+  get_process_times_fn = (GetProcessTimes_Proc)
+    GetProcAddress (kernel32, "GetProcessTimes");
+
   g_b_init_is_windows_9x = 0;
   g_b_init_open_process_token = 0;
   g_b_init_get_token_information = 0;
diff --git a/src/w32menu.c b/src/w32menu.c
index 5f507ad76c0..f86bfa3b7db 100644
--- a/src/w32menu.c
+++ b/src/w32menu.c
@@ -23,6 +23,7 @@ Boston, MA 02110-1301, USA.  */
 
 #include <signal.h>
 #include <stdio.h>
+#include <mbstring.h>
 
 #include "lisp.h"
 #include "keyboard.h"
@@ -2262,8 +2263,9 @@ static int
 add_menu_item (HMENU menu, widget_value *wv, HMENU item)
 {
   UINT fuFlags;
-  char *out_string;
+  char *out_string, *p, *q;
   int return_value;
+  size_t nlen, orig_len;
 
   if (name_is_separator (wv->name))
     {
@@ -2287,6 +2289,33 @@ add_menu_item (HMENU menu, widget_value *wv, HMENU item)
       else
         out_string = wv->name;
 
+      /* Quote any special characters within the menu item's text and
+         key binding.  */
+      nlen = orig_len = strlen (out_string);
+      for (p = out_string; *p; p = _mbsinc (p))
+        {
+          if (_mbsnextc (p) == '&')
+            nlen++;
+        }
+      if (nlen > orig_len)
+        {
+          p = out_string;
+          out_string = alloca (nlen + 1);
+          q = out_string;
+          while (*p)
+            {
+              if (_mbsnextc (p) == '&')
+                {
+                  _mbsncpy (q, p, 1);
+                  q = _mbsinc (q);
+                }
+              _mbsncpy (q, p, 1);
+              p = _mbsinc (p);
+              q = _mbsinc (q);
+            }
+          *q = '\0';
+        }
+
       if (item != NULL)
         fuFlags = MF_POPUP;
       else if (wv->title || wv->call_data == 0)
diff --git a/src/xdisp.c b/src/xdisp.c
index afa7f92a1cc..7c7fedeb0b8 100644
--- a/src/xdisp.c
+++ b/src/xdisp.c
@@ -9367,7 +9367,7 @@ update_tool_bar (f, save_match_data)
      struct frame *f;
      int save_match_data;
 {
-#ifdef USE_GTK
+#if defined (USE_GTK) || USE_MAC_TOOLBAR
   int do_update = FRAME_EXTERNAL_TOOL_BAR (f);
 #else
   int do_update = WINDOWP (f->tool_bar_window)
@@ -9833,7 +9833,7 @@ redisplay_tool_bar (f)
   struct it it;
   struct glyph_row *row;
 
-#ifdef USE_GTK
+#if defined (USE_GTK) || USE_MAC_TOOLBAR
   if (FRAME_EXTERNAL_TOOL_BAR (f))
     update_frame_tool_bar (f);
   return 0;
@@ -13478,7 +13478,7 @@ redisplay_window (window, just_this_one_p)
 #ifdef HAVE_WINDOW_SYSTEM
       if (FRAME_WINDOW_P (f))
         {
-#ifdef USE_GTK
+#if defined (USE_GTK) || USE_MAC_TOOLBAR
           redisplay_tool_bar_p = FRAME_EXTERNAL_TOOL_BAR (f);
 #else
           redisplay_tool_bar_p = WINDOWP (f->tool_bar_window)
diff --git a/src/xfns.c b/src/xfns.c
index e51dea84118..0dab5d9dd64 100644
--- a/src/xfns.c
+++ b/src/xfns.c
@@ -73,8 +73,13 @@ Boston, MA 02110-1301, USA.  */
 #include <X11/Shell.h>
 
 #ifndef USE_MOTIF
+#ifdef HAVE_XAW3D
+#include <X11/Xaw3d/Paned.h>
+#include <X11/Xaw3d/Label.h>
+#else /* !HAVE_XAW3D */
 #include <X11/Xaw/Paned.h>
 #include <X11/Xaw/Label.h>
+#endif /* HAVE_XAW3D */
 #endif /* USE_MOTIF */
 
 #ifdef USG
diff --git a/src/xmenu.c b/src/xmenu.c
index 4390d9429af..a9e0d4be001 100644
--- a/src/xmenu.c
+++ b/src/xmenu.c
@@ -82,7 +82,11 @@ Boston, MA 02110-1301, USA.  */
 #include <X11/StringDefs.h>
 #include <X11/Shell.h>
 #ifdef USE_LUCID
+#ifdef HAVE_XAW3D
+#include <X11/Xaw3d/Paned.h>
+#else /* !HAVE_XAW3D */
 #include <X11/Xaw/Paned.h>
+#endif /* HAVE_XAW3D */
 #endif /* USE_LUCID */
 #include "../lwlib/lwlib.h"
 #else /* not USE_X_TOOLKIT */