Merged from miles@gnu.org--gnu-2005 (patch 296-306)

Patches applied:

 * miles@gnu.org--gnu-2005/emacs--cvs-trunk--0--patch-296
   Update from CVS

 * miles@gnu.org--gnu-2005/emacs--cvs-trunk--0--patch-297
   Update from CVS

 * miles@gnu.org--gnu-2005/emacs--cvs-trunk--0--patch-298
   Update from CVS

 * miles@gnu.org--gnu-2005/emacs--cvs-trunk--0--patch-299
   Update from CVS

 * miles@gnu.org--gnu-2005/emacs--cvs-trunk--0--patch-300
   Update from CVS

 * miles@gnu.org--gnu-2005/emacs--cvs-trunk--0--patch-301
   Update from CVS

 * miles@gnu.org--gnu-2005/emacs--cvs-trunk--0--patch-302
   Update from CVS

 * miles@gnu.org--gnu-2005/emacs--cvs-trunk--0--patch-303
   Update from CVS

 * miles@gnu.org--gnu-2005/emacs--cvs-trunk--0--patch-304
   Update from CVS

 * miles@gnu.org--gnu-2005/emacs--cvs-trunk--0--patch-305
   Update from CVS

 * miles@gnu.org--gnu-2005/emacs--cvs-trunk--0--patch-306
   Update from CVS

git-archimport-id: lorentey@elte.hu--2004/emacs--multi-tty--0--patch-344

13 files changed, 385 insertions, 202 deletions

diff --git a/src/ChangeLog b/src/ChangeLog
index a8e248a1718..a86f78e5b96 100644
--- a/src/ChangeLog
+++ b/src/ChangeLog
@@ -1,3 +1,54 @@
+2005-05-13  YAMAMOTO Mitsuharu  <mituharu@math.s.chiba-u.ac.jp>
+
+        * emacs.c (main) [MAC_OS8]: Call init_atimer before mac_term_init.
+
+        * keyboard.c (readable_events) [USE_TOOLKIT_SCROLL_BARS]: Regard
+        toolkit scroll bar thumb drag events as squeezable and prevent
+        redisplay from being paused by them.
+
+        * mac.c [!MAC_OSX]: Include keyboard.h and syssignal.h.
+        [!MAC_OSX] (target_ticks): Remove variable.
+        [!MAC_OSX] (check_alarm, pause, index): Remove functions.
+        [!MAC_OSX && __MRC__] (sys_strftime): Likewise.
+        [!MAC_OSX] (select): If fd 0 is not set in rfds and some input
+        event occurs before timeout, behave as if the function were
+        interrupted.
+        [!MAC_OSX] (sigblock, sigsetmask, alarm): Simulate SIGALRM
+        handling using Time Manager routines.
+        [!MAC_OSX] (mac_atimer_task, mac_atimer_qlink, signal_mask): New
+        variables.
+        [!MAC_OSX] (mac_atimer_handler, set_mac_atimer, remove_mac_atimer)
+        (setitimer): New functions.
+
+        * macfns.c, macmenu.c: Don't include signal.h.
+
+        * macterm.c [USE_TOOLKIT_SCROLL_BARS] (get_control_part_bounds):
+        Rename from get_control_part_bound.  All callers changed.
+        (x_scroll_bar_clear): New function.
+        (x_clear_frame): Use it.
+        (XTset_vertical_scroll_bar): Don't call Draw1Control.
+        (x_scroll_bar_handle_click): Change type of second argument from
+        int to ControlPartCode.
+        (check_alarm): Remove declaration.
+        (XTread_Socket) [!TARGET_API_MAC_CARBON]: Don't call it.
+        (XTread_Socket): Use ControlPartCode instead of SInt16.
+
+2005-05-13  Nozomu Ando  <nand@mac.com>
+
+        * unexmacosx.c: Include assert.h.
+        (MACOSX_MALLOC_MULT16): New define.
+        [MACOSX_MALLOC_MULT16] (ptr_in_unexec_regions): Determine whether
+        ptr is in unexec regions by checking it is multiple of 16.
+        (unexec_malloc_header_t): New typedef.
+        (unexec_malloc, unexec_realloc, unexec_free): Store and use
+        allocated size information in unexec_malloc_header.
+
+2005-05-10  Richard M. Stallman  <rms@gnu.org>
+
+        * xterm.c (noinclude): Add #undef.
+
+        * image.c, xfns.c, xmenu.c: Don't include signal.h.
+
 2005-05-09  Juanma Barranquero  <lekktu@gmail.com>
 
         * fileio.c (Fexpand_file_name, Frename_file, Fadd_name_to_file)
diff --git a/src/emacs.c b/src/emacs.c
index 67cf1eb03be..a1805c6497a 100644
--- a/src/emacs.c
+++ b/src/emacs.c
@@ -1326,6 +1326,7 @@ main (argc, argv
       syms_of_search ();
       syms_of_frame ();
 
+      init_atimer ();
       mac_term_init (build_string ("Mac"), NULL, NULL);
       init_keyboard ();
 #endif
@@ -1351,7 +1352,9 @@ main (argc, argv
 #ifdef CLASH_DETECTION
   init_filelock ();
 #endif
+#ifndef MAC_OS8
   init_atimer ();
+#endif
   running_asynch_code = 0;
 
   /* Handle --unibyte and the EMACS_UNIBYTE envvar,
diff --git a/src/image.c b/src/image.c
index 6a1fc7aa795..f03adfdc48f 100644
--- a/src/image.c
+++ b/src/image.c
@@ -20,7 +20,6 @@ the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
 Boston, MA 02111-1307, USA.  */
 
 #include <config.h>
-#include <signal.h>
 #include <stdio.h>
 #include <math.h>
 #include <ctype.h>
diff --git a/src/keyboard.c b/src/keyboard.c
index e78b51d247b..596df7aed79 100644
--- a/src/keyboard.c
+++ b/src/keyboard.c
@@ -3525,9 +3525,11 @@ readable_events (flags)
      READABLE_EVENTS_FILTER_EVENTS is set, report it as empty.  */
   if (kbd_fetch_ptr != kbd_store_ptr)
     {
-      int have_live_event = 1;
-
-      if (flags & READABLE_EVENTS_FILTER_EVENTS)
+      if (flags & (READABLE_EVENTS_FILTER_EVENTS
+#ifdef USE_TOOLKIT_SCROLL_BARS
+                   | READABLE_EVENTS_IGNORE_SQUEEZABLES
+#endif
+                   ))
         {
           struct input_event *event;
 
@@ -3535,16 +3537,29 @@ readable_events (flags)
                    ? kbd_fetch_ptr
                    : kbd_buffer);
 
-          while (have_live_event && event->kind == FOCUS_IN_EVENT)
-            {
-              event++;
+          do
+            {
+              if (!(
+#ifdef USE_TOOLKIT_SCROLL_BARS
+                    (flags & READABLE_EVENTS_FILTER_EVENTS) &&
+#endif
+                    event->kind == FOCUS_IN_EVENT)
+#ifdef USE_TOOLKIT_SCROLL_BARS
+                  && !((flags & READABLE_EVENTS_IGNORE_SQUEEZABLES)
+                       && event->kind == SCROLL_BAR_CLICK_EVENT
+                       && event->part == scroll_bar_handle
+                       && event->modifiers == 0)
+#endif
+                  )
+                return 1;
+              event++;
               if (event == kbd_buffer + KBD_BUFFER_SIZE)
                 event = kbd_buffer;
-              if (event == kbd_store_ptr)
-                have_live_event = 0;
-            }
+            }
+          while (event != kbd_store_ptr);
         }
-      if (have_live_event) return 1;
+      else
+        return 1;
     }
 
 #ifdef HAVE_MOUSE
@@ -6543,7 +6558,7 @@ lucid_event_type_list_p (object)
    If READABLE_EVENTS_FILTER_EVENTS is set in FLAGS, ignore internal
    events (FOCUS_IN_EVENT).
    If READABLE_EVENTS_IGNORE_SQUEEZABLES is set in FLAGS, ignore mouse
-   movements. */
+   movements and toolkit scroll bar thumb drags. */
 
 static void
 get_input_pending (addr, flags)
diff --git a/src/mac.c b/src/mac.c
index 14257fdee94..eaf4f029cf1 100644
--- a/src/mac.c
+++ b/src/mac.c
@@ -1672,37 +1672,7 @@ sys_fopen (const char *name, const char *mode)
 }
 
 
-long target_ticks = 0;
-
-#ifdef __MRC__
-__sigfun alarm_signal_func = (__sigfun) 0;
-#elif __MWERKS__
-__signal_func_ptr alarm_signal_func = (__signal_func_ptr) 0;
-#else /* not __MRC__ and not __MWERKS__ */
-You lose!!!
-#endif /* not __MRC__ and not __MWERKS__ */
-
-
-/* These functions simulate SIG_ALRM.  The stub for function signal
-   stores the signal handler function in alarm_signal_func if a
-   SIG_ALRM is encountered.  check_alarm is called in XTread_socket,
-   which emacs calls periodically.  A pending alarm is represented by
-   a non-zero target_ticks value.  check_alarm calls the handler
-   function pointed to by alarm_signal_func if one has been set up and
-   an alarm is pending.  */
-
-void
-check_alarm ()
-{
-  if (target_ticks && TickCount () > target_ticks)
-    {
-      target_ticks = 0;
-      if (alarm_signal_func)
-        (*alarm_signal_func)(SIGALRM);
-    }
-}
-
-
+#include "keyboard.h"
 extern Boolean mac_wait_next_event (EventRecord *, UInt32, Boolean);
 
 int
@@ -1713,25 +1683,17 @@ select (n,  rfds, wfds, efds, timeout)
   SELECT_TYPE *efds;
   struct timeval *timeout;
 {
-#if TARGET_API_MAC_CARBON
   OSErr err;
+#if TARGET_API_MAC_CARBON
   EventTimeout timeout_sec =
     (timeout
      ? (EMACS_SECS (*timeout) * kEventDurationSecond
         + EMACS_USECS (*timeout) * kEventDurationMicrosecond)
      : kEventDurationForever);
 
-  if (FD_ISSET (0, rfds))
-    {
-      BLOCK_INPUT;
-      err = ReceiveNextEvent (0, NULL, timeout_sec, kEventLeaveInQueue, NULL);
-      UNBLOCK_INPUT;
-      if (err == noErr)
-        return 1;
-      else
-        FD_ZERO (rfds);
-    }
-  return 0;
+  BLOCK_INPUT;
+  err = ReceiveNextEvent (0, NULL, timeout_sec, kEventLeaveInQueue, NULL);
+  UNBLOCK_INPUT;
 #else /* not TARGET_API_MAC_CARBON */
   EventRecord e;
   UInt32 sleep_time = EMACS_SECS (*timeout) * 60 +
@@ -1746,47 +1708,62 @@ select (n,  rfds, wfds, efds, timeout)
      read_avail_input which in turn calls XTread_socket to poll for
      these events.  Otherwise these never get processed except but a
      very slow poll timer.  */
-  if (FD_ISSET (0, rfds) && mac_wait_next_event (&e, sleep_time, false))
-    return 1;
-
-  return 0;
+  if (mac_wait_next_event (&e, sleep_time, false))
+    err = noErr;
+  else
+    err = -9875;                /* eventLoopTimedOutErr */
 #endif /* not TARGET_API_MAC_CARBON */
-}
-
-
-/* Called in sys_select to wait for an alarm signal to arrive.  */
-
-int
-pause ()
-{
-  EventRecord e;
-  unsigned long tick;
-
-  if (!target_ticks)  /* no alarm pending */
-    return -1;
 
-  if ((tick = TickCount ()) < target_ticks)
-    WaitNextEvent (0, &e, target_ticks - tick, NULL); /* Accept no event;
-                                                         just wait. by T.I. */
+  if (FD_ISSET (0, rfds))
+    if (err == noErr)
+      return 1;
+    else
+      {
+        FD_ZERO (rfds);
+        return 0;
+      }
+  else
+    if (err == noErr)
+      {
+        if (input_polling_used ())
+          {
+            /* It could be confusing if a real alarm arrives while
+               processing the fake one.  Turn it off and let the
+               handler reset it.  */
+            extern void poll_for_input_1 P_ ((void));
+            int old_poll_suppress_count = poll_suppress_count;
+            poll_suppress_count = 1;
+            poll_for_input_1 ();
+            poll_suppress_count = old_poll_suppress_count;
+          }
+        errno = EINTR;
+        return -1;
+      }
+    else
+      return 0;
+}
 
-  target_ticks = 0;
-  if (alarm_signal_func)
-    (*alarm_signal_func)(SIGALRM);
 
-  return 0;
-}
+/* Simulation of SIGALRM.  The stub for function signal stores the
+   signal handler function in alarm_signal_func if a SIGALRM is
+   encountered.  */
 
+#include <signal.h>
+#include "syssignal.h"
 
-int
-alarm (int seconds)
-{
-  long remaining = target_ticks ? (TickCount () - target_ticks) / 60 : 0;
+static TMTask mac_atimer_task;
 
-  target_ticks = seconds ? TickCount () + 60 * seconds : 0;
+static QElemPtr mac_atimer_qlink = (QElemPtr) &mac_atimer_task;
 
-  return (remaining < 0) ? 0 : (unsigned int) remaining;
-}
+static int signal_mask = 0;
 
+#ifdef __MRC__
+__sigfun alarm_signal_func = (__sigfun) 0;
+#elif __MWERKS__
+__signal_func_ptr alarm_signal_func = (__signal_func_ptr) 0;
+#else /* not __MRC__ and not __MWERKS__ */
+You lose!!!
+#endif /* not __MRC__ and not __MWERKS__ */
 
 #undef signal
 #ifdef __MRC__
@@ -1819,6 +1796,128 @@ sys_signal (int signal_num, __signal_func_ptr signal_func)
 }
 
 
+static pascal void
+mac_atimer_handler (qlink)
+     TMTaskPtr qlink;
+{
+  if (alarm_signal_func)
+    (alarm_signal_func) (SIGALRM);
+}
+
+
+static void
+set_mac_atimer (count)
+     long count;
+{
+  static TimerUPP mac_atimer_handlerUPP = NULL;
+
+  if (mac_atimer_handlerUPP == NULL)
+    mac_atimer_handlerUPP = NewTimerUPP (mac_atimer_handler);
+  mac_atimer_task.tmCount = 0;
+  mac_atimer_task.tmAddr = mac_atimer_handlerUPP;
+  mac_atimer_qlink = (QElemPtr) &mac_atimer_task;
+  InsTime (mac_atimer_qlink);
+  if (count)
+    PrimeTime (mac_atimer_qlink, count);
+}
+
+
+int
+remove_mac_atimer (remaining_count)
+     long *remaining_count;
+{
+  if (mac_atimer_qlink)
+    {
+      RmvTime (mac_atimer_qlink);
+      if (remaining_count)
+        *remaining_count = mac_atimer_task.tmCount;
+      mac_atimer_qlink = NULL;
+
+      return 0;
+    }
+  else
+    return -1;
+}
+
+
+int
+sigblock (int mask)
+{
+  int old_mask = signal_mask;
+
+  signal_mask |= mask;
+
+  if ((old_mask ^ signal_mask) & sigmask (SIGALRM))
+    remove_mac_atimer (NULL);
+
+  return old_mask;
+}
+
+
+int
+sigsetmask (int mask)
+{
+  int old_mask = signal_mask;
+
+  signal_mask = mask;
+
+  if ((old_mask ^ signal_mask) & sigmask (SIGALRM))
+    if (signal_mask & sigmask (SIGALRM))
+      remove_mac_atimer (NULL);
+    else
+      set_mac_atimer (mac_atimer_task.tmCount);
+
+  return old_mask;
+}
+
+
+int
+alarm (int seconds)
+{
+  long remaining_count;
+
+  if (remove_mac_atimer (&remaining_count) == 0)
+    {
+      set_mac_atimer (seconds * 1000);
+
+      return remaining_count / 1000;
+    }
+  else
+    {
+      mac_atimer_task.tmCount = seconds * 1000;
+
+      return 0;
+    }
+}
+
+
+int
+setitimer (which, value, ovalue)
+     int which;
+     const struct itimerval *value;
+     struct itimerval *ovalue;
+{
+  long remaining_count;
+  long count = (EMACS_SECS (value->it_value) * 1000
+                + (EMACS_USECS (value->it_value) + 999) / 1000);
+
+  if (remove_mac_atimer (&remaining_count) == 0)
+    {
+      if (ovalue)
+        {
+          bzero (ovalue, sizeof (*ovalue));
+          EMACS_SET_SECS_USECS (ovalue->it_value, remaining_count / 1000,
+                                (remaining_count % 1000) * 1000);
+        }
+      set_mac_atimer (count);
+    }
+  else
+    mac_atimer_task.tmCount = count;
+
+  return 0;
+}
+
+
 /* gettimeofday should return the amount of time (in a timeval
    structure) since midnight today.  The toolbox function Microseconds
    returns the number of microseconds (in a UnsignedWide value) since
@@ -1946,35 +2045,6 @@ sys_time (time_t *timer)
 }
 
 
-/* MPW strftime broken for "%p" format */
-#ifdef __MRC__
-#undef strftime
-#include <time.h>
-size_t
-sys_strftime (char * s, size_t maxsize, const char * format,
-              const struct tm * timeptr)
-{
-  if (strcmp (format, "%p") == 0)
-    {
-      if (maxsize < 3)
-        return 0;
-      if (timeptr->tm_hour < 12)
-        {
-          strcpy (s, "AM");
-          return 2;
-        }
-      else
-        {
-          strcpy (s, "PM");
-          return 2;
-        }
-    }
-  else
-    return strftime (s, maxsize, format, timeptr);
-}
-#endif  /* __MRC__ */
-
-
 /* no subprocesses, empty wait */
 
 int
@@ -1993,13 +2063,6 @@ croak (char *badfunc)
 
 
 char *
-index (const char * str, int chr)
-{
-  return strchr (str, chr);
-}
-
-
-char *
 mktemp (char *template)
 {
   int len, k;
@@ -2187,20 +2250,6 @@ sys_subshell ()
 }
 
 
-int
-sigsetmask (int x)
-{
-  return 0;
-}
-
-
-int
-sigblock (int mask)
-{
-  return 0;
-}
-
-
 void
 request_sigio (void)
 {
diff --git a/src/macfns.c b/src/macfns.c
index a8b685582d5..d0dd9b9c072 100644
--- a/src/macfns.c
+++ b/src/macfns.c
@@ -22,7 +22,6 @@ Boston, MA 02111-1307, USA.  */
 
 #include <config.h>
 
-#include <signal.h>
 #include <stdio.h>
 #include <math.h>
 #include <limits.h>
diff --git a/src/macmenu.c b/src/macmenu.c
index 35615cc3796..eb870176f12 100644
--- a/src/macmenu.c
+++ b/src/macmenu.c
@@ -21,7 +21,6 @@ Boston, MA 02111-1307, USA.  */
 /* Contributed by Andrew Choi (akochoi@mac.com).  */
 
 #include <config.h>
-#include <signal.h>
 
 #include <stdio.h>
 #include "lisp.h"
diff --git a/src/macselect.c b/src/macselect.c
index a115c9b3229..890bb62d1d4 100644
--- a/src/macselect.c
+++ b/src/macselect.c
@@ -1104,9 +1104,11 @@ next communication only.  After the communication, this variable is
 set to nil.  */);
   Vnext_selection_coding_system = Qnil;
 
+#ifdef MAC_OSX
   DEFVAR_LISP ("mac-services-selection", &Vmac_services_selection,
                doc: /* Selection name for communication via Services menu.  */);
-  Vmac_services_selection = intern ("CLIPBOARD");
+  Vmac_services_selection = intern ("PRIMARY");
+#endif
 
   QPRIMARY   = intern ("PRIMARY");      staticpro (&QPRIMARY);
   QSECONDARY = intern ("SECONDARY");    staticpro (&QSECONDARY);
diff --git a/src/macterm.c b/src/macterm.c
index 1e8aba4e178..47c77e6dd56 100644
--- a/src/macterm.c
+++ b/src/macterm.c
@@ -3271,11 +3271,9 @@ x_clear_frame ()
   BLOCK_INPUT;
   XClearWindow (FRAME_MAC_DISPLAY (f), FRAME_MAC_WINDOW (f));
 
-#if 0  /* Clearing frame on Mac OS clears scroll bars.  */
   /* We have to clear the scroll bars, too.  If we have changed
      colors or something like that, then they should be notified.  */
   x_scroll_bar_clear (f);
-#endif
 
   XFlush (FRAME_MAC_DISPLAY (f));
   UNBLOCK_INPUT;
@@ -4135,12 +4133,12 @@ XTmouse_position (fp, insist, bar_window, part, x, y, time)
 static pascal void scroll_bar_timer_callback P_ ((EventLoopTimerRef, void *));
 static OSStatus install_scroll_bar_timer P_ ((void));
 static OSStatus set_scroll_bar_timer P_ ((EventTimerInterval));
-static int control_part_code_to_scroll_bar_part P_((ControlPartCode));
+static int control_part_code_to_scroll_bar_part P_ ((ControlPartCode));
 static void construct_scroll_bar_click P_ ((struct scroll_bar *, int,
                                             unsigned long,
                                             struct input_event *));
-static OSErr get_control_part_bound P_((ControlHandle, ControlPartCode,
-                                        Rect *));
+static OSErr get_control_part_bounds P_ ((ControlHandle, ControlPartCode,
+                                          Rect *));
 static void x_scroll_bar_handle_press P_ ((struct scroll_bar *,
                                            ControlPartCode,
                                            unsigned long,
@@ -4267,7 +4265,7 @@ construct_scroll_bar_click (bar, part, timestamp, bufp)
 }
 
 static OSErr
-get_control_part_bound (ch, part_code, rect)
+get_control_part_bounds (ch, part_code, rect)
      ControlHandle ch;
      ControlPartCode part_code;
      Rect *rect;
@@ -4340,8 +4338,8 @@ x_scroll_bar_handle_drag (win, bar, mouse_pos, timestamp, bufp)
       int top, top_range;
       Rect r;
 
-      get_control_part_bound (SCROLL_BAR_CONTROL_HANDLE (bar),
-                              kControlIndicatorPart, &r);
+      get_control_part_bounds (SCROLL_BAR_CONTROL_HANDLE (bar),
+                               kControlIndicatorPart, &r);
 
       if (GC_NILP (bar->dragging))
         XSETINT (bar->dragging, mouse_pos.v - r.top);
@@ -4669,13 +4667,11 @@ XTset_vertical_scroll_bar (w, portion, whole, position)
       BLOCK_INPUT;
 
       /* If already correctly positioned, do nothing.  */
-      if (XINT (bar->left) == sb_left
-          && XINT (bar->top) == top
-          && XINT (bar->width) == sb_width
-          && XINT (bar->height) == height)
-        Draw1Control (ch);
-      else
-        {
+      if (!(XINT (bar->left) == sb_left
+            && XINT (bar->top) == top
+            && XINT (bar->width) == sb_width
+            && XINT (bar->height) == height))
+        {
           /* Clear areas not covered by the scroll bar because it's not as
              wide as the area reserved for it .  This makes sure a
              previous mode line display is cleared after C-x 2 C-x 1, for
@@ -4724,11 +4720,11 @@ XTset_vertical_scroll_bar (w, portion, whole, position)
 
       /* Move the scroll bar thumb to the top.  */
       SetControl32BitValue (ch, 0);
-      get_control_part_bound (ch, kControlIndicatorPart, &r0);
+      get_control_part_bounds (ch, kControlIndicatorPart, &r0);
 
       /* Move the scroll bar thumb to the bottom.  */
       SetControl32BitValue (ch, 1);
-      get_control_part_bound (ch, kControlIndicatorPart, &r1);
+      get_control_part_bounds (ch, kControlIndicatorPart, &r1);
 
       UnionRect (&r0, &r1, &r0);
       XSETINT (bar->track_top, r0.top);
@@ -4876,7 +4872,7 @@ XTjudge_scroll_bars (f)
 static void
 x_scroll_bar_handle_click (bar, part_code, er, bufp)
      struct scroll_bar *bar;
-     int part_code;
+     ControlPartCode part_code;
      EventRecord *er;
      struct input_event *bufp;
 {
@@ -5034,6 +5030,21 @@ x_scroll_bar_report_motion (fp, bar_window, part, x, y, time)
 
   *time = last_mouse_movement_time;
 }
+
+
+/* The screen has been cleared so we may have changed foreground or
+   background colors, and the scroll bars may need to be redrawn.
+   Clear out the scroll bars, and ask for expose events, so we can
+   redraw them.  */
+
+void
+x_scroll_bar_clear (f)
+     FRAME_PTR f;
+{
+  XTcondemn_scroll_bars (f);
+  XTjudge_scroll_bars (f);
+}
+
 
 /***********************************************************************
                              Text Cursor
@@ -7498,7 +7509,6 @@ OSErr install_window_handler (WindowPtr);
 
 extern void init_emacs_passwd_dir ();
 extern int emacs_main (int, char **, char **);
-extern void check_alarm ();
 
 extern void initialize_applescript();
 extern void terminate_applescript();
@@ -8650,23 +8660,18 @@ profiler_exit_proc ()
 #endif
 
 /* These few functions implement Emacs as a normal Mac application
-   (almost): set up the heap and the Toolbox, handle necessary
-   system events plus a few simple menu events.  They also set up
-   Emacs's access to functions defined in the rest of this file.
-   Emacs uses function hooks to perform all its terminal I/O.  A
-   complete list of these functions appear in termhooks.h.  For what
-   they do, read the comments there and see also w32term.c and
-   xterm.c.  What's noticeably missing here is the event loop, which
-   is normally present in most Mac application.  After performing the
-   necessary Mac initializations, main passes off control to
-   emacs_main (corresponding to main in emacs.c).  Emacs_main calls
-   mac_read_socket (defined further below) to read input.  This is
-   where WaitNextEvent is called to process Mac events.  This is also
-   where check_alarm in sysdep.c is called to simulate alarm signals.
-   This makes the cursor jump back to its correct position after
-   briefly jumping to that of the matching parenthesis, print useful
-   hints and prompts in the minibuffer after the user stops typing for
-   a wait, etc.  */
+   (almost): set up the heap and the Toolbox, handle necessary system
+   events plus a few simple menu events.  They also set up Emacs's
+   access to functions defined in the rest of this file.  Emacs uses
+   function hooks to perform all its terminal I/O.  A complete list of
+   these functions appear in termhooks.h.  For what they do, read the
+   comments there and see also w32term.c and xterm.c.  What's
+   noticeably missing here is the event loop, which is normally
+   present in most Mac application.  After performing the necessary
+   Mac initializations, main passes off control to emacs_main
+   (corresponding to main in emacs.c).  Emacs_main calls XTread_socket
+   (defined further below) to read input.  This is where
+   WaitNextEvent/ReceiveNextEvent is called to process Mac events.  */
 
 #ifdef MAC_OS8
 #undef main
@@ -8929,7 +8934,7 @@ XTread_socket (sd, expected, hold_quit)
         case mouseUp:
           {
             WindowPtr window_ptr;
-            SInt16 part_code;
+            ControlPartCode part_code;
             int tool_bar_p = 0;
 
 #if USE_CARBON_EVENTS
@@ -8973,7 +8978,7 @@ XTread_socket (sd, expected, hold_quit)
                   SelectWindow (window_ptr);
                 else
                   {
-                    SInt16 control_part_code;
+                    ControlPartCode control_part_code;
                     ControlHandle ch;
                     Point mouse_loc = er.where;
 #ifdef MAC_OSX
@@ -9548,10 +9553,6 @@ XTread_socket (sd, expected, hold_quit)
       pending_autoraise_frame = 0;
     }
 
-#if !TARGET_API_MAC_CARBON
-  check_alarm ();  /* simulate the handling of a SIGALRM */
-#endif
-
   UNBLOCK_INPUT;
   return count;
 }
diff --git a/src/unexmacosx.c b/src/unexmacosx.c
index 1f2b4c96620..fc369eab7cd 100644
--- a/src/unexmacosx.c
+++ b/src/unexmacosx.c
@@ -105,6 +105,8 @@ Boston, MA 02111-1307, USA.  */
 #include <objc/malloc.h>
 #endif
 
+#include <assert.h>
+
 
 #define VERBOSE 1
 
@@ -998,6 +1000,23 @@ unexec_init_emacs_zone ()
   malloc_set_zone_name (emacs_zone, "EmacsZone");
 }
 
+#ifndef MACOSX_MALLOC_MULT16
+#define MACOSX_MALLOC_MULT16 1
+#endif
+
+typedef struct unexec_malloc_header {
+  union {
+    char c[8];
+    size_t size;
+  } u;
+} unexec_malloc_header_t;
+
+#if MACOSX_MALLOC_MULT16
+
+#define ptr_in_unexec_regions(p) ((((vm_address_t) (p)) & 8) != 0)
+
+#else
+
 int
 ptr_in_unexec_regions (void *ptr)
 {
@@ -1011,36 +1030,75 @@ ptr_in_unexec_regions (void *ptr)
   return 0;
 }
 
+#endif
+
 void *
 unexec_malloc (size_t size)
 {
   if (in_dumped_exec)
-    return malloc (size);
+    {
+      void *p;
+
+      p = malloc (size);
+#if MACOSX_MALLOC_MULT16
+      assert (((vm_address_t) p % 16) == 0);
+#endif
+      return p;
+    }
   else
-    return malloc_zone_malloc (emacs_zone, size);
+    {
+      unexec_malloc_header_t *ptr;
+
+      ptr = (unexec_malloc_header_t *)
+        malloc_zone_malloc (emacs_zone, size + sizeof (unexec_malloc_header_t));
+      ptr->u.size = size;
+      ptr++;
+#if MACOSX_MALLOC_MULT16
+      assert (((vm_address_t) ptr % 16) == 8);
+#endif
+      return (void *) ptr;
+    }
 }
 
 void *
 unexec_realloc (void *old_ptr, size_t new_size)
 {
   if (in_dumped_exec)
-    if (ptr_in_unexec_regions (old_ptr))
-      {
-        char *p = malloc (new_size);
-        /* 2002-04-15 T. Ikegami <ikegami@adam.uprr.pr>.  The original
-           code to get size failed to reallocate read_buffer
-           (lread.c).  */
-        int old_size = malloc_default_zone()->size (emacs_zone, old_ptr);
-        int size = new_size > old_size ? old_size : new_size;
-
-        if (size)
-          memcpy (p, old_ptr, size);
-        return p;
-      }
-    else
-      return realloc (old_ptr, new_size);
+    {
+      void *p;
+
+      if (ptr_in_unexec_regions (old_ptr))
+        {
+          p = (size_t *) malloc (new_size);
+          size_t old_size = ((unexec_malloc_header_t *) old_ptr)[-1].u.size;
+          size_t size = new_size > old_size ? old_size : new_size;
+
+          if (size)
+            memcpy (p, old_ptr, size);
+        }
+      else
+        {
+          p = realloc (old_ptr, new_size);
+        }
+#if MACOSX_MALLOC_MULT16
+      assert (((vm_address_t) p % 16) == 0);
+#endif
+      return p;
+    }
   else
-    return malloc_zone_realloc (emacs_zone, old_ptr, new_size);
+    {
+      unexec_malloc_header_t *ptr;
+
+      ptr = (unexec_malloc_header_t *)
+        malloc_zone_realloc (emacs_zone, (unexec_malloc_header_t *) old_ptr - 1,
+                             new_size + sizeof (unexec_malloc_header_t));
+      ptr->u.size = new_size;
+      ptr++;
+#if MACOSX_MALLOC_MULT16
+      assert (((vm_address_t) ptr % 16) == 8);
+#endif
+      return (void *) ptr;
+    }
 }
 
 void
@@ -1052,7 +1110,7 @@ unexec_free (void *ptr)
         free (ptr);
     }
   else
-    malloc_zone_free (emacs_zone, ptr);
+    malloc_zone_free (emacs_zone, (unexec_malloc_header_t *) ptr - 1);
 }
 
 /* arch-tag: 1a784f7b-a184-4c4f-9544-da8619593d72
diff --git a/src/xfns.c b/src/xfns.c
index 666acfec773..44e1dbae0c2 100644
--- a/src/xfns.c
+++ b/src/xfns.c
@@ -20,7 +20,6 @@ the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
 Boston, MA 02111-1307, USA.  */
 
 #include <config.h>
-#include <signal.h>
 #include <stdio.h>
 #include <math.h>
 
diff --git a/src/xmenu.c b/src/xmenu.c
index 1a2386fe916..931d2a87904 100644
--- a/src/xmenu.c
+++ b/src/xmenu.c
@@ -33,8 +33,10 @@ Boston, MA 02111-1307, USA.  */
 
 #include <config.h>
 
+#if 0  /* Why was this included?  And without syssignal.h?  */
 /* On 4.3 this loses if it comes after xterm.h.  */
 #include <signal.h>
+#endif
 
 #include <stdio.h>
 
diff --git a/src/xterm.c b/src/xterm.c
index ebd0954edb7..aa5f9829105 100644
--- a/src/xterm.c
+++ b/src/xterm.c
@@ -7794,6 +7794,12 @@ x_error_handler (display, error)
 #define NO_INLINE
 #endif
 
+/* Some versions of GNU/Linux define noinline in their headers.  */
+
+#ifdef noinline
+#undef noinline
+#endif
+
 /* On older GCC versions, just putting x_error_quitter
    after x_error_handler prevents inlining into the former.  */