Merge from mainline.

32 files changed, 1241 insertions, 606 deletions

diff --git a/src/.gdbinit b/src/.gdbinit
index c4604e6e2b0..1bfc293c466 100644
--- a/src/.gdbinit
+++ b/src/.gdbinit
@@ -1150,17 +1150,18 @@ Print $ assuming it is a list font (font-spec, font-entity, or font-object).
 end
 
 define xbacktrace
-  set $bt = backtrace_list
-  while $bt
-    xgettype ($bt->function)
+  set $bt = backtrace_top ()
+  while backtrace_p ($bt)
+    set $fun = backtrace_function ($bt)
+    xgettype $fun
     if $type == Lisp_Symbol
-      xprintsym ($bt->function)
-      printf " (0x%x)\n", $bt->args
+      xprintsym $fun
+      printf " (0x%x)\n", backtrace_args ($bt)
     else
-      xgetptr $bt->function
+      xgetptr $fun
       printf "0x%x ", $ptr
       if $type == Lisp_Vectorlike
-        xgetptr ($bt->function)
+        xgetptr $fun
         set $size = ((struct Lisp_Vector *) $ptr)->header.size
         if ($size & PSEUDOVECTOR_FLAG)
           output (enum pvec_type) (($size & PVEC_TYPE_MASK) >> PSEUDOVECTOR_AREA_BITS)
@@ -1172,7 +1173,7 @@ define xbacktrace
       end
       echo \n
     end
-    set $bt = $bt->next
+    set $bt = backtrace_next ($bt)
   end
 end
 document xbacktrace
@@ -1220,8 +1221,8 @@ end
 
 # Show Lisp backtrace after normal backtrace.
 define hookpost-backtrace
-  set $bt = backtrace_list
-  if $bt
+  set $bt = backtrace_top ()
+  if backtrace_p ($bt)
     echo \n
     echo Lisp Backtrace:\n
     xbacktrace
diff --git a/src/ChangeLog b/src/ChangeLog
index 65a49bae1dc..7fdd456c9a7 100644
--- a/src/ChangeLog
+++ b/src/ChangeLog
@@ -1,3 +1,245 @@
+2013-06-03  Eli Zaretskii  <eliz@gnu.org>
+
+        * w32console.c (initialize_w32_display): Return the dimensions of
+        the console window via 2 additional arguments, not via the current
+        frame.  This avoids crashes due to overrunning the bounds of
+        frame's decode_mode_spec_buffer, which is not resized following
+        the change of the frame dimensions from the initial 10x10.
+
+        * w32term.h (w32_initialize_display_info): Adjust prototype.
+
+        * term.c (init_tty): Take dimensions of the frame from the values
+        returned by initialize_w32_display.
+
+        * Makefile.in (GFILENOTIFY_CFLAGS, GFILENOTIFY_LIBS): New variables.
+        (ALL_CFLAGS): Add $(GFILENOTIFY_CFLAGS).
+        (LIBES): Add $(GFILENOTIFY_LIBS).
+
+        * w32inevt.c (handle_file_notifications): Add dummy implementation
+        for !HAVE_W32NOTIFY.
+
+        * w32term.c: Wrap code with HAVE_W32NOTIFY.
+
+2013-06-03  Jan Djärv  <jan.h.d@swipnet.se>
+
+        * xgselect.c: Replace #if defined ... with #ifdef HAVE_GLIB.
+
+        * process.c (wait_reading_process_output): Call xg_select if HAVE_GLIB.
+
+        * Makefile.in (XGSELOBJ): New, xgselect.o if GLib is used, or empty.
+
+2013-06-03  Paul Eggert  <eggert@cs.ucla.edu>
+
+        Fix minor problems found by static checking.
+        * data.c (pure_write_error):
+        Use xsignal2, not Fsignal, as Fsignal might return.
+        * eval.c (set_backtrace_debug_on_exit): Now static.
+        (backtrace_p, backtrace_top, backtrace_next, record_in_backtrace):
+        No longer inline.  EXTERN_INLINE is needed only for functions
+        defined in .h files.  Reindent function header as per GNU style.
+        (backtrace_p, backtrace_top, backtrace_next):
+        Mark EXTERNALLY_VISIBLE so they don't get optimized away by the
+        compiler or linker.  Add extern decls to pacify gcc -Wall.
+        * frame.c, frame.h (Qgeometry, Qworkarea, Qmm_size, Qframes, Qsource):
+        Now static.
+        * frame.c (free_monitors): Define only on platforms that need it.
+        * nsterm.m (ns_term_init):
+        * process.c (catch_child_signal):
+        Don't worry about whether SIGCHLD is defined, as SIGCHLD is
+        defined on all porting targets these days.
+        * process.c, process.h (catch_child_signal):
+        Make it extern only if NS_IMPL_GNUSTEP is defined.
+
+2013-06-03  Eli Zaretskii  <eliz@gnu.org>
+
+        * w32.c (gettimeofday): Make the signature identical to prototype
+        in nt/inc/sys/time.h.
+
+2013-06-03  Stefan Monnier  <monnier@iro.umontreal.ca>
+
+        * eval.c (backtrace_p, backtrace_top, backtrace_next): Export them to
+        .gdbinit.
+
+        * keyboard.c (safe_run_hooks_error): Improve error message.
+
+        * data.c (pure_write_error): Add `object' argument.
+        * puresize.h (CHECK_IMPURE): Use it.
+
+2013-06-03  Michael Albinus  <michael.albinus@gmx.de>
+
+        * Makefile.in (NOTIFY_OBJ): New variable.
+        (base_obj): Replace inotify.o by $(NOTIFY_OBJ).
+
+        * emacs.c (main): Use HAVE_W32NOTIFY to wrap respective code.
+        Call syms_of_gfilenotify.
+
+        * gfilenotify.c: New file.
+
+        * keyboard.c (Qfile_notify): New variable.  Replaces Qfile_inotify
+        and Qfile_w32notify.
+        (top): Wrap respective code by HAVE_GFILENOTIFY, HAVE_INOTIFY,
+        HAVE_W32NOTIFY and USE_FILE_NOTIFY.
+
+        * lisp.h: Declare syms_of_gfilenotify.
+
+        * termhooks.h (e): Wrap enum by USE_FILE_NOTIFY.
+
+2013-06-03  Stefan Monnier  <monnier@iro.umontreal.ca>
+
+        Merge the specpdl and backtrace stacks.  Make the structure of the
+        specpdl entries more obvious via a tagged union of structs.
+        * lisp.h (BITS_PER_PTRDIFF_T): New constant.
+        (enum specbind_tag): New enum.
+        (struct specbinding): Make it a tagged union of structs.
+        Add a case for backtrace records.
+        (specpdl_symbol, specpdl_old_value, specpdl_where, specpdl_arg)
+        (specpdl_func, backtrace_function, backtrace_nargs, backtrace_args)
+        (backtrace_debug_on_exit): New accessors.
+        (struct backtrace): Remove.
+        (struct catchtag): Remove backlist field.
+        * data.c (let_shadows_buffer_binding_p, let_shadows_global_binding_p):
+        Move to eval.c.
+        (Flocal_variable_p): Speed up the common case where the binding is
+        already loaded.
+        * eval.c (backtrace_list): Remove.
+        (set_specpdl_symbol, set_specpdl_old_value): Remove.
+        (set_backtrace_args, set_backtrace_nargs)
+        (set_backtrace_debug_on_exit, backtrace_p, backtrace_top)
+        (backtrace_next): New functions.
+        (Fdefvaralias, Fdefvar): Adjust to new specpdl format.
+        (unwind_to_catch, internal_lisp_condition_case)
+        (internal_condition_case, internal_condition_case_1)
+        (internal_condition_case_2, internal_condition_case_n): Don't bother
+        with backtrace_list any more.
+        (Fsignal): Adjust to new backtrace format.
+        (grow_specpdl): Move up.
+        (record_in_backtrace): New function.
+        (eval_sub, Ffuncall): Use it.
+        (apply_lambda): Adjust to new backtrace format.
+        (let_shadows_buffer_binding_p, let_shadows_global_binding_p): Move from
+        data.c.
+        (specbind): Adjust to new specpdl format.  Simplify.
+        (record_unwind_protect, unbind_to): Adjust to new specpdl format.
+        (Fbacktrace_debug, Fbacktrace, Fbacktrace_frame): Adjust to new
+        backtrace format.
+        (mark_backtrace): Remove.
+        (mark_specpdl, get_backtrace, backtrace_top_function): New functions.
+        * xdisp.c (redisplay_internal): Use record_in_backtrace.
+        * alloc.c (Fgarbage_collect): Use record_in_backtrace.
+        Use mark_specpdl.
+        * profiler.c (record_backtrace): Use get_backtrace.
+        (handle_profiler_signal): Use backtrace_top_function.
+        * .gdbinit (xbacktrace, hookpost-backtrace): Use new backtrace
+        accessor functions.
+
+2013-06-02  Jan Djärv  <jan.h.d@swipnet.se>
+
+        * process.h (catch_child_signal): Declare.
+
+        * process.c (catch_child_signal): New function.
+        (init_process_emacs): Call it.
+
+        * nsterm.m: Include process.h if NS_IMPL_GNUSTEP.
+        (ns_menu_bar_is_hidden, menu_will_open_state): Define only if
+        NS_IMPL_COCOA.
+        (x_set_cursor_type): Remove declaration.
+        (ns_update_begin): Only use r and bp if NS_IMPL_COCOA.
+        (ns_update_end, ns_focus, ns_unfocus): Remove GNUStep specific code.
+        (x_set_window_size): Remove 3 pixels from toolbar if NS_IMPL_GNUSTEP.
+        (ns_get_color): Use F suffix on float.
+        (ns_color_to_lisp, ns_query_color): Use EmacsCGFloat.
+        (ns_get_rgb_color): Remove.
+        (x_set_frame_alpha): Move view inside NS_IMPL_COCOA.
+        (note_mouse_movement): x and y are CGFloat.
+        (ns_draw_fringe_bitmap): Remove unused rowY.
+        Change #if to COCOA && >= 10_6.
+        (ns_draw_window_cursor): Remove unused overspill.
+        (ns_draw_underwave): width and x are EamcsCGFloat.
+        (ns_draw_box): thickness is CGFloat.
+        (ns_dumpglyphs_image): Change #if to COCOA && >= 10_6.
+        (ns_send_appdefined): When NS_IMPL_GNUSTEP, redirect to main thread
+        if not in main thread.
+        (ns_get_pending_menu_title, ns_check_menu_open)
+        (ns_check_pending_open_menu): Put inside #if COCOA && >= 10_5.
+        (ns_term_init): Call catch_child_signal if NS_IMPL_GNUSTEP && SIGCHLD.
+        (sendFromMainThread:): New method.
+        (changeFont:): size is CGFloat.
+        (keyDown:): Check for Delete when NS_IMPL_GNUSTEP.
+        Disable warning about permanent text.
+        (characterIndexForPoint:): Adjust return type depending on GNUStep
+        version.
+        (mouseDown:): delta is CGFloat.
+        (updateFrameSize): Remove unised variable f.
+        (initFrameFromEmacs): Move toggleButton inside NS_IMPL_COCOA.
+        Cast float to EmacsCGFloat.
+        (windowWillUseStandardFrame:defaultFrame:): Set maximized_height
+        also to -1 when restoring.
+        (windowDidExitFullScreen:): Put call to updateCollectionBehaviour
+        inside NS_IMPL_COCOA.
+        (toggleFullScreen:): Put call to toggleFullScreen inside
+        NS_IMPL_COCOA.  Cast float to EmacsCGFloat.
+        (setPosition:portion:whole:): por is CGFloat.
+        (getMouseMotionPart:window:x:y:): Add F suffix to float.
+        (mouseDown:): Use CGFloat.
+        (mouseDragged:): Remove unised variable edge.
+        (EmacsDocument): Implement for NS_IMPL_GNUSTEP.
+
+        * nsterm.h (EmacsCGFloat): Typedef for OSX and GNUStep when the size
+        of CGFloat differs.
+        (EmacsApp): New variable nextappdefined.  Declare sendFromMainThread
+        when NS_IMPL_GNUSTEP.
+        (EmacsDocument): Declare when NS_IMPL_GNUSTEP.
+        (EmacsView): Remove unlockFocusNeedsFlush, add windowDidMove.
+        (EmacsToolbar): Add clearAll.  Add tag argument to
+        addDisplayItemWithImage.
+        (EmacsSavePanel, EmacsOpenPanel): Remove getFilename and getDirectory.
+
+        * nsselect.m (ns_get_local_selection): Remove unused variable type.
+
+        * nsmenu.m (ns_update_menubar): Make static.
+        (x_activate_menubar): Surround with ifdef NS_IMPL_COCOA
+        (fillWithWidgetValue:): Add cast to SEL for setAction.
+        (addSubmenuWithTitle:forFrame:): Add cast to SEL for action.
+        (update_frame_tool_bar): Update code for GNUStep.
+        (clearAll): New method.
+        (addDisplayItemWithImage:idx:tag:helpText:enabled:): Handle new tag
+        argument. Call insertItemWithItemIdentifier when NS_IMPL_GNUSTEP. Move
+        identifierToItem setObject and activeIdentifiers addObject before
+        call to insertItemWithItemIdentifier.
+        (validateVisibleItems): Fix indentation.
+        (toolbarAllowedItemIdentifiers:): Return activeIdentifiers.
+        (initWithContentRect:styleMask:backing:defer:): Add ClosableWindow and
+        UtilityWindow to aStyle, remove call to setStyleMask.
+
+        * nsimage.m (setXBMColor:, getPixelAtX:Y:): Use EmacsCGFloat.
+
+        * nsfont.m (ns_attribute_fvalue, ns_spec_to_descriptor)
+        (ns_charset_covers, ns_get_covering_families, nsfont_open):
+        Use F suffix on floats.
+        (ns_char_width): Returns CGFloat.
+        (ns_ascii_average_width): w is CGFloat instead of float.
+        (nsfont_draw): cbuf and c are unsigned. Cast to char* in call to
+        DPSxshow.
+        (ns_glyph_metrics): CGFloat instead of float.
+
+        * nsfns.m (x_set_foreground_color, x_set_background_color): Use
+        EmacsCGFloat.
+        (ns_implicitly_set_icon_type, Fx_create_frame): Make static, remove
+        unused variables.
+        (Fns_read_file_name): Keep track if panel is for save.  Use
+        ns_filename_from_panel/ns_directory_from_panel.
+        (Fns_list_services): delegate only used for COCOA.
+        (Fns_convert_utf8_nfd_to_nfc): Remove warning for GNUStep.  Just
+        return the input if GNUStep.
+        (x_screen_planes): Remove.
+        (Fxw_color_values): Use EmacsCGFloat
+        (Fns_display_monitor_attributes_list): Only get screen number for
+        Cocoa.
+        (getDirectory, getFilename): Removed from EmacsOpenPanel and
+        EmacsSavePanel.
+        (EmacsOpenPanel:ok:): Use ns_filename_from_panel and
+        ns_directory_from_panel.
+
 2013-06-01  Paul Eggert  <eggert@cs.ucla.edu>
 
         * process.c (handle_child_signal): Also use WCONTINUED.
diff --git a/src/Makefile.in b/src/Makefile.in
index 2fa7fb37348..9d7857e4ca2 100644
--- a/src/Makefile.in
+++ b/src/Makefile.in
@@ -156,6 +156,13 @@ SETTINGS_LIBS = @SETTINGS_LIBS@
 ## gtkutil.o if USE_GTK, else empty.
 GTK_OBJ=@GTK_OBJ@
 
+## gfilenotify.o if HAVE_GFILENOTIFY.
+## inotify.o if HAVE_INOTIFY.
+## w32notify.o if HAVE_W32NOTIFY.
+NOTIFY_OBJ = @NOTIFY_OBJ@
+GFILENOTIFY_CFLAGS = @GFILENOTIFY_CFLAGS@
+GFILENOTIFY_LIBS = @GFILENOTIFY_LIBS@
+
 ## -ltermcap, or -lncurses, or -lcurses, or "".
 LIBS_TERMCAP=@LIBS_TERMCAP@
 ## terminfo.o if TERMINFO, else tparam.o.
@@ -200,10 +207,13 @@ LIBXMENU=@LIBXMENU@
 
 ## xmenu.o if HAVE_X_WINDOWS, else empty.
 XMENU_OBJ=@XMENU_OBJ@
-## xterm.o xfns.o xselect.o xrdb.o xsmfns.o xsettings.o xgselect.o if
+## xterm.o xfns.o xselect.o xrdb.o xsmfns.o xsettings.o if
 ## HAVE_X_WINDOWS, else empty.
 XOBJ=@XOBJ@
 
+# xgselect.o if linking with GLib, else empty
+XGSELOBJ=@XGSELOBJ@
+
 TOOLKIT_LIBW=@TOOLKIT_LIBW@
 
 ## Only used if HAVE_X11, in LIBX_OTHER.
@@ -337,7 +347,7 @@ ALL_CFLAGS=-Demacs $(MYCPPFLAGS) -I. -I$(srcdir) \
   $(LIBXML2_CFLAGS) $(DBUS_CFLAGS) $(XRANDR_CFLAGS) $(XINERAMA_CFLAGS) \
   $(SETTINGS_CFLAGS) $(FREETYPE_CFLAGS) $(FONTCONFIG_CFLAGS) \
   $(LIBOTF_CFLAGS) $(M17N_FLT_CFLAGS) $(DEPFLAGS) \
-  $(LIBGNUTLS_CFLAGS) \
+  $(LIBGNUTLS_CFLAGS) $(GFILENOTIFY_CFLAGS) \
   $(WARN_CFLAGS) $(WERROR_CFLAGS) $(CFLAGS)
 ALL_OBJC_CFLAGS=$(ALL_CFLAGS) $(GNU_OBJC_CFLAGS)
 
@@ -363,10 +373,10 @@ base_obj = dispnew.o frame.o scroll.o xdisp.o menu.o $(XMENU_OBJ) window.o \
         syntax.o $(UNEXEC_OBJ) bytecode.o \
         process.o gnutls.o callproc.o \
         region-cache.o sound.o atimer.o \
-        doprnt.o intervals.o textprop.o composite.o xml.o inotify.o \
+        doprnt.o intervals.o textprop.o composite.o xml.o $(NOTIFY_OBJ) \
         profiler.o \
         $(MSDOS_OBJ) $(MSDOS_X_OBJ) $(NS_OBJ) $(CYGWIN_OBJ) $(FONT_OBJ) \
-        $(W32_OBJ) $(WINDOW_SYSTEM_OBJ)
+        $(W32_OBJ) $(WINDOW_SYSTEM_OBJ) $(XGSELOBJ)
 obj = $(base_obj) $(NS_OBJC_OBJ)
 
 ## Object files used on some machine or other.
@@ -419,7 +429,7 @@ LIBES = $(LIBS) $(W32_LIBS) $(LIBS_GNUSTEP) $(LIBX_BASE) $(LIBIMAGE) \
    $(LIBS_TERMCAP) $(GETLOADAVG_LIBS) $(SETTINGS_LIBS) $(LIBSELINUX_LIBS) \
    $(FREETYPE_LIBS) $(FONTCONFIG_LIBS) $(LIBOTF_LIBS) $(M17N_FLT_LIBS) \
    $(LIBGNUTLS_LIBS) $(LIB_PTHREAD) $(LIB_PTHREAD_SIGMASK) \
-   $(LIB_MATH)
+   $(GFILENOTIFY_LIBS) $(LIB_MATH)
 
 all: emacs$(EXEEXT) $(OTHER_FILES)
 .PHONY: all
diff --git a/src/alloc.c b/src/alloc.c
index 7a56c78e2ba..cce0fff4fd4 100644
--- a/src/alloc.c
+++ b/src/alloc.c
@@ -5165,7 +5165,6 @@ returns nil, because real GC can't be done.
 See Info node `(elisp)Garbage Collection'.  */)
   (void)
 {
-  struct specbinding *bind;
   struct buffer *nextb;
   char stack_top_variable;
   ptrdiff_t i;
@@ -5174,7 +5173,6 @@ See Info node `(elisp)Garbage Collection'.  */)
   EMACS_TIME start;
   Lisp_Object retval = Qnil;
   size_t tot_before = 0;
-  struct backtrace backtrace;
 
   if (abort_on_gc)
     emacs_abort ();
@@ -5185,12 +5183,7 @@ See Info node `(elisp)Garbage Collection'.  */)
     return Qnil;
 
   /* Record this function, so it appears on the profiler's backtraces.  */
-  backtrace.next = backtrace_list;
-  backtrace.function = Qautomatic_gc;
-  backtrace.args = &Qnil;
-  backtrace.nargs = 0;
-  backtrace.debug_on_exit = 0;
-  backtrace_list = &backtrace;
+  record_in_backtrace (Qautomatic_gc, &Qnil, 0);
 
   check_cons_list ();
 
@@ -5257,11 +5250,7 @@ See Info node `(elisp)Garbage Collection'.  */)
   for (i = 0; i < staticidx; i++)
     mark_object (*staticvec[i]);
 
-  for (bind = specpdl; bind != specpdl_ptr; bind++)
-    {
-      mark_object (bind->symbol);
-      mark_object (bind->old_value);
-    }
+  mark_specpdl ();
   mark_terminals ();
   mark_kboards ();
 
@@ -5295,7 +5284,6 @@ See Info node `(elisp)Garbage Collection'.  */)
       mark_object (handler->var);
     }
   }
-  mark_backtrace ();
 #endif
 
 #ifdef HAVE_WINDOW_SYSTEM
@@ -5486,7 +5474,6 @@ See Info node `(elisp)Garbage Collection'.  */)
       malloc_probe (swept);
     }
 
-  backtrace_list = backtrace.next;
   return retval;
 }
 
diff --git a/src/data.c b/src/data.c
index 6622088b648..9f756de014a 100644
--- a/src/data.c
+++ b/src/data.c
@@ -100,9 +100,9 @@ wrong_type_argument (register Lisp_Object predicate, register Lisp_Object value)
 }
 
 void
-pure_write_error (void)
+pure_write_error (Lisp_Object obj)
 {
-  error ("Attempt to modify read-only object");
+  xsignal2 (Qerror, build_string ("Attempt to modify read-only object"), obj);
 }
 
 void
@@ -1069,40 +1069,6 @@ DEFUN ("set", Fset, Sset, 2, 2, 0,
   return newval;
 }
 
-/* Return true if SYMBOL currently has a let-binding
-   which was made in the buffer that is now current.  */
-
-static bool
-let_shadows_buffer_binding_p (struct Lisp_Symbol *symbol)
-{
-  struct specbinding *p;
-
-  for (p = specpdl_ptr; p > specpdl; )
-    if ((--p)->func == NULL
-        && CONSP (p->symbol))
-      {
-        struct Lisp_Symbol *let_bound_symbol = XSYMBOL (XCAR (p->symbol));
-        eassert (let_bound_symbol->redirect != SYMBOL_VARALIAS);
-        if (symbol == let_bound_symbol
-            && XBUFFER (XCDR (XCDR (p->symbol))) == current_buffer)
-          return 1;
-      }
-
-  return 0;
-}
-
-static bool
-let_shadows_global_binding_p (Lisp_Object symbol)
-{
-  struct specbinding *p;
-
-  for (p = specpdl_ptr; p > specpdl; )
-    if ((--p)->func == NULL && EQ (p->symbol, symbol))
-      return 1;
-
-  return 0;
-}
-
 /* Store the value NEWVAL into SYMBOL.
    If buffer/frame-locality is an issue, WHERE specifies which context to use.
    (nil stands for the current buffer/frame).
@@ -1841,17 +1807,18 @@ BUFFER defaults to the current buffer.  */)
         XSETBUFFER (tmp, buf);
         XSETSYMBOL (variable, sym); /* Update in case of aliasing.  */
 
-        for (tail = BVAR (buf, local_var_alist); CONSP (tail); tail = XCDR (tail))
-          {
-            elt = XCAR (tail);
-            if (EQ (variable, XCAR (elt)))
-              {
-                eassert (!blv->frame_local);
-                eassert (blv_found (blv) || !EQ (blv->where, tmp));
-                return Qt;
-              }
-          }
-        eassert (!blv_found (blv) || !EQ (blv->where, tmp));
+        if (EQ (blv->where, tmp)) /* The binding is already loaded.  */
+          return blv_found (blv) ? Qt : Qnil;
+        else
+          for (tail = BVAR (buf, local_var_alist); CONSP (tail); tail = XCDR (tail))
+            {
+              elt = XCAR (tail);
+              if (EQ (variable, XCAR (elt)))
+                {
+                  eassert (!blv->frame_local);
+                  return Qt;
+                }
+            }
         return Qnil;
       }
     case SYMBOL_FORWARDED:
diff --git a/src/emacs.c b/src/emacs.c
index 5115126577b..4e439a601b1 100644
--- a/src/emacs.c
+++ b/src/emacs.c
@@ -1252,7 +1252,9 @@ Using an Emacs configured with --with-x-toolkit=lucid does not have this problem
 
 #ifdef WINDOWSNT
   globals_of_w32 ();
+#ifdef HAVE_W32NOTIFY
   globals_of_w32notify ();
+#endif
   /* Initialize environment from registry settings.  */
   init_environment (argv);
   init_ntproc (dumping); /* must precede init_editfns.  */
@@ -1409,6 +1411,10 @@ Using an Emacs configured with --with-x-toolkit=lucid does not have this problem
       syms_of_gnutls ();
 #endif
 
+#ifdef HAVE_GFILENOTIFY
+      syms_of_gfilenotify ();
+#endif /* HAVE_GFILENOTIFY */
+
 #ifdef HAVE_INOTIFY
       syms_of_inotify ();
 #endif /* HAVE_INOTIFY */
@@ -1419,7 +1425,9 @@ Using an Emacs configured with --with-x-toolkit=lucid does not have this problem
 
 #ifdef WINDOWSNT
       syms_of_ntterm ();
+#ifdef HAVE_W32NOTIFY
       syms_of_w32notify ();
+#endif /* HAVE_W32NOTIFY */
 #endif /* WINDOWSNT */
 
       syms_of_profiler ();
diff --git a/src/eval.c b/src/eval.c
index 69483a9b205..d1d074df777 100644
--- a/src/eval.c
+++ b/src/eval.c
@@ -32,8 +32,6 @@ along with GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.  */
 #include "xterm.h"
 #endif
 
-struct backtrace *backtrace_list;
-
 #if !BYTE_MARK_STACK
 static
 #endif
@@ -105,7 +103,7 @@ static EMACS_INT when_entered_debugger;
 
 /* The function from which the last `signal' was called.  Set in
    Fsignal.  */
-
+/* FIXME: We should probably get rid of this!  */
 Lisp_Object Vsignaling_function;
 
 /* If non-nil, Lisp code must not be run since some part of Emacs is
@@ -117,20 +115,48 @@ Lisp_Object inhibit_lisp_code;
 static Lisp_Object funcall_lambda (Lisp_Object, ptrdiff_t, Lisp_Object *);
 static Lisp_Object apply_lambda (Lisp_Object fun, Lisp_Object args);
 
-/* Functions to set Lisp_Object slots of struct specbinding.  */
+/* Functions to modify slots of backtrace records.  */
+
+static void
+set_backtrace_args (struct specbinding *pdl, Lisp_Object *args)
+{ eassert (pdl->kind == SPECPDL_BACKTRACE); pdl->v.bt.args = args; }
+
+static void
+set_backtrace_nargs (struct specbinding *pdl, ptrdiff_t n)
+{ eassert (pdl->kind == SPECPDL_BACKTRACE); pdl->v.bt.nargs = n; }
 
 static void
-set_specpdl_symbol (Lisp_Object symbol)
+set_backtrace_debug_on_exit (struct specbinding *pdl, bool doe)
+{ eassert (pdl->kind == SPECPDL_BACKTRACE); pdl->v.bt.debug_on_exit = doe; }
+
+/* Helper functions to scan the backtrace.  */
+
+bool backtrace_p (struct specbinding *) EXTERNALLY_VISIBLE;
+struct specbinding *backtrace_top (void) EXTERNALLY_VISIBLE;
+struct specbinding *backtrace_next (struct specbinding *pdl) EXTERNALLY_VISIBLE;
+
+bool backtrace_p (struct specbinding *pdl)
+{ return pdl >= specpdl; }
+
+struct specbinding *
+backtrace_top (void)
 {
-  specpdl_ptr->symbol = symbol;
+  struct specbinding *pdl = specpdl_ptr - 1;
+  while (backtrace_p (pdl) && pdl->kind != SPECPDL_BACKTRACE)
+    pdl--;
+  return pdl;
 }
 
-static void
-set_specpdl_old_value (Lisp_Object oldval)
+struct specbinding *
+backtrace_next (struct specbinding *pdl)
 {
-  specpdl_ptr->old_value = oldval;
+  pdl--;
+  while (backtrace_p (pdl) && pdl->kind != SPECPDL_BACKTRACE)
+    pdl--;
+  return pdl;
 }
 
+
 void
 init_eval_once (void)
 {
@@ -151,7 +177,6 @@ init_eval (void)
   specpdl_ptr = specpdl;
   catchlist = 0;
   handlerlist = 0;
-  backtrace_list = 0;
   Vquit_flag = Qnil;
   debug_on_next_call = 0;
   lisp_eval_depth = 0;
@@ -234,7 +259,7 @@ static void
 do_debug_on_call (Lisp_Object code)
 {
   debug_on_next_call = 0;
-  backtrace_list->debug_on_exit = 1;
+  set_backtrace_debug_on_exit (specpdl_ptr - 1, true);
   call_debugger (Fcons (code, Qnil));
 }
 
@@ -530,9 +555,8 @@ The return value is BASE-VARIABLE.  */)
     struct specbinding *p;
 
     for (p = specpdl_ptr; p > specpdl; )
-      if ((--p)->func == NULL
-          && (EQ (new_alias,
-                  CONSP (p->symbol) ? XCAR (p->symbol) : p->symbol)))
+      if ((--p)->kind >= SPECPDL_LET
+          && (EQ (new_alias, specpdl_symbol (p))))
         error ("Don't know how to make a let-bound variable an alias");
   }
 
@@ -597,8 +621,9 @@ usage: (defvar SYMBOL &optional INITVALUE DOCSTRING)  */)
           struct specbinding *pdl = specpdl_ptr;
           while (pdl > specpdl)
             {
-              if (EQ ((--pdl)->symbol, sym) && !pdl->func
-                  && EQ (pdl->old_value, Qunbound))
+              if ((--pdl)->kind >= SPECPDL_LET
+                  && EQ (specpdl_symbol (pdl), sym)
+                  && EQ (specpdl_old_value (pdl), Qunbound))
                 {
                   message_with_string
                     ("Warning: defvar ignored because %s is let-bound",
@@ -937,7 +962,7 @@ usage: (catch TAG BODY...)  */)
 
 /* Set up a catch, then call C function FUNC on argument ARG.
    FUNC should return a Lisp_Object.
-   This is how catches are done from within C code. */
+   This is how catches are done from within C code.  */
 
 Lisp_Object
 internal_catch (Lisp_Object tag, Lisp_Object (*func) (Lisp_Object), Lisp_Object arg)
@@ -949,7 +974,6 @@ internal_catch (Lisp_Object tag, Lisp_Object (*func) (Lisp_Object), Lisp_Object
   c.next = catchlist;
   c.tag = tag;
   c.val = Qnil;
-  c.backlist = backtrace_list;
   c.handlerlist = handlerlist;
   c.lisp_eval_depth = lisp_eval_depth;
   c.pdlcount = SPECPDL_INDEX ();
@@ -1014,7 +1038,6 @@ unwind_to_catch (struct catchtag *catch, Lisp_Object value)
 #ifdef DEBUG_GCPRO
   gcpro_level = gcprolist ? gcprolist->level + 1 : 0;
 #endif
-  backtrace_list = catch->backlist;
   lisp_eval_depth = catch->lisp_eval_depth;
 
   sys_longjmp (catch->jmp, 1);
@@ -1115,7 +1138,6 @@ internal_lisp_condition_case (volatile Lisp_Object var, Lisp_Object bodyform,
 
   c.tag = Qnil;
   c.val = Qnil;
-  c.backlist = backtrace_list;
   c.handlerlist = handlerlist;
   c.lisp_eval_depth = lisp_eval_depth;
   c.pdlcount = SPECPDL_INDEX ();
@@ -1131,7 +1153,7 @@ internal_lisp_condition_case (volatile Lisp_Object var, Lisp_Object bodyform,
 
       /* Note that this just undoes the binding of h.var; whoever
          longjumped to us unwound the stack to c.pdlcount before
-         throwing. */
+         throwing.  */
       unbind_to (c.pdlcount, Qnil);
       return val;
     }
@@ -1170,7 +1192,6 @@ internal_condition_case (Lisp_Object (*bfun) (void), Lisp_Object handlers,
 
   c.tag = Qnil;
   c.val = Qnil;
-  c.backlist = backtrace_list;
   c.handlerlist = handlerlist;
   c.lisp_eval_depth = lisp_eval_depth;
   c.pdlcount = SPECPDL_INDEX ();
@@ -1208,7 +1229,6 @@ internal_condition_case_1 (Lisp_Object (*bfun) (Lisp_Object), Lisp_Object arg,
 
   c.tag = Qnil;
   c.val = Qnil;
-  c.backlist = backtrace_list;
   c.handlerlist = handlerlist;
   c.lisp_eval_depth = lisp_eval_depth;
   c.pdlcount = SPECPDL_INDEX ();
@@ -1250,7 +1270,6 @@ internal_condition_case_2 (Lisp_Object (*bfun) (Lisp_Object, Lisp_Object),
 
   c.tag = Qnil;
   c.val = Qnil;
-  c.backlist = backtrace_list;
   c.handlerlist = handlerlist;
   c.lisp_eval_depth = lisp_eval_depth;
   c.pdlcount = SPECPDL_INDEX ();
@@ -1294,7 +1313,6 @@ internal_condition_case_n (Lisp_Object (*bfun) (ptrdiff_t, Lisp_Object *),
 
   c.tag = Qnil;
   c.val = Qnil;
-  c.backlist = backtrace_list;
   c.handlerlist = handlerlist;
   c.lisp_eval_depth = lisp_eval_depth;
   c.pdlcount = SPECPDL_INDEX ();
@@ -1362,7 +1380,6 @@ See also the function `condition-case'.  */)
     = (NILP (error_symbol) ? Fcar (data) : error_symbol);
   register Lisp_Object clause = Qnil;
   struct handler *h;
-  struct backtrace *bp;
 
   immediate_quit = 0;
   abort_on_gc = 0;
@@ -1398,13 +1415,13 @@ See also the function `condition-case'.  */)
      too.  Don't do this when ERROR_SYMBOL is nil, because that
      is a memory-full error.  */
   Vsignaling_function = Qnil;
-  if (backtrace_list && !NILP (error_symbol))
+  if (!NILP (error_symbol))
     {
-      bp = backtrace_list->next;
-      if (bp && EQ (bp->function, Qerror))
-        bp = bp->next;
-      if (bp)
-        Vsignaling_function = bp->function;
+      struct specbinding *pdl = backtrace_next (backtrace_top ());
+      if (backtrace_p (pdl) && EQ (backtrace_function (pdl), Qerror))
+        pdl = backtrace_next (pdl);
+      if (backtrace_p (pdl))
+        Vsignaling_function = backtrace_function (pdl);
     }
 
   for (h = handlerlist; h; h = h->next)
@@ -1901,6 +1918,36 @@ If LEXICAL is t, evaluate using lexical scoping.  */)
   return unbind_to (count, eval_sub (form));
 }
 
+static void
+grow_specpdl (void)
+{
+  register ptrdiff_t count = SPECPDL_INDEX ();
+  ptrdiff_t max_size = min (max_specpdl_size, PTRDIFF_MAX);
+  if (max_size <= specpdl_size)
+    {
+      if (max_specpdl_size < 400)
+        max_size = max_specpdl_size = 400;
+      if (max_size <= specpdl_size)
+        signal_error ("Variable binding depth exceeds max-specpdl-size", Qnil);
+    }
+  specpdl = xpalloc (specpdl, &specpdl_size, 1, max_size, sizeof *specpdl);
+  specpdl_ptr = specpdl + count;
+}
+
+void
+record_in_backtrace (Lisp_Object function, Lisp_Object *args, ptrdiff_t nargs)
+{
+  eassert (nargs >= UNEVALLED);
+  if (specpdl_ptr == specpdl + specpdl_size)
+    grow_specpdl ();
+  specpdl_ptr->kind = SPECPDL_BACKTRACE;
+  specpdl_ptr->v.bt.function = function;
+  specpdl_ptr->v.bt.args = args;
+  specpdl_ptr->v.bt.nargs = nargs;
+  specpdl_ptr->v.bt.debug_on_exit = false;
+  specpdl_ptr++;
+}
+
 /* Eval a sub-expression of the current expression (i.e. in the same
    lexical scope).  */
 Lisp_Object
@@ -1908,7 +1955,6 @@ eval_sub (Lisp_Object form)
 {
   Lisp_Object fun, val, original_fun, original_args;
   Lisp_Object funcar;
-  struct backtrace backtrace;
   struct gcpro gcpro1, gcpro2, gcpro3;
 
   if (SYMBOLP (form))
@@ -1946,12 +1992,8 @@ eval_sub (Lisp_Object form)
   original_fun = XCAR (form);
   original_args = XCDR (form);
 
-  backtrace.next = backtrace_list;
-  backtrace.function = original_fun; /* This also protects them from gc.  */
-  backtrace.args = &original_args;
-  backtrace.nargs = UNEVALLED;
-  backtrace.debug_on_exit = 0;
-  backtrace_list = &backtrace;
+  /* This also protects them from gc.  */
+  record_in_backtrace (original_fun, &original_args, UNEVALLED);
 
   if (debug_on_next_call)
     do_debug_on_call (Qt);
@@ -2005,8 +2047,8 @@ eval_sub (Lisp_Object form)
               gcpro3.nvars = argnum;
             }
 
-          backtrace.args = vals;
-          backtrace.nargs = XINT (numargs);
+          set_backtrace_args (specpdl_ptr - 1, vals);
+          set_backtrace_nargs (specpdl_ptr - 1, XINT (numargs));
 
           val = (XSUBR (fun)->function.aMANY) (XINT (numargs), vals);
           UNGCPRO;
@@ -2027,8 +2069,8 @@ eval_sub (Lisp_Object form)
 
           UNGCPRO;
 
-          backtrace.args = argvals;
-          backtrace.nargs = XINT (numargs);
+          set_backtrace_args (specpdl_ptr - 1, argvals);
+          set_backtrace_nargs (specpdl_ptr - 1, XINT (numargs));
 
           switch (i)
             {
@@ -2118,9 +2160,9 @@ eval_sub (Lisp_Object form)
   check_cons_list ();
 
   lisp_eval_depth--;
-  if (backtrace.debug_on_exit)
+  if (backtrace_debug_on_exit (specpdl_ptr - 1))
     val = call_debugger (Fcons (Qexit, Fcons (val, Qnil)));
-  backtrace_list = backtrace.next;
+  specpdl_ptr--;
 
   return val;
 }
@@ -2600,7 +2642,6 @@ usage: (funcall FUNCTION &rest ARGUMENTS)  */)
   ptrdiff_t numargs = nargs - 1;
   Lisp_Object lisp_numargs;
   Lisp_Object val;
-  struct backtrace backtrace;
   register Lisp_Object *internal_args;
   ptrdiff_t i;
 
@@ -2614,12 +2655,8 @@ usage: (funcall FUNCTION &rest ARGUMENTS)  */)
         error ("Lisp nesting exceeds `max-lisp-eval-depth'");
     }
 
-  backtrace.next = backtrace_list;
-  backtrace.function = args[0];
-  backtrace.args = &args[1];    /* This also GCPROs them.  */
-  backtrace.nargs = nargs - 1;
-  backtrace.debug_on_exit = 0;
-  backtrace_list = &backtrace;
+  /* This also GCPROs them.  */
+  record_in_backtrace (args[0], &args[1], nargs - 1);
 
   /* Call GC after setting up the backtrace, so the latter GCPROs the args.  */
   maybe_gc ();
@@ -2744,9 +2781,9 @@ usage: (funcall FUNCTION &rest ARGUMENTS)  */)
     }
   check_cons_list ();
   lisp_eval_depth--;
-  if (backtrace.debug_on_exit)
+  if (backtrace_debug_on_exit (specpdl_ptr - 1))
     val = call_debugger (Fcons (Qexit, Fcons (val, Qnil)));
-  backtrace_list = backtrace.next;
+  specpdl_ptr--;
   return val;
 }
 
@@ -2778,15 +2815,17 @@ apply_lambda (Lisp_Object fun, Lisp_Object args)
 
   UNGCPRO;
 
-  backtrace_list->args = arg_vector;
-  backtrace_list->nargs = i;
+  set_backtrace_args (specpdl_ptr - 1, arg_vector);
+  set_backtrace_nargs (specpdl_ptr - 1, i);
   tem = funcall_lambda (fun, numargs, arg_vector);
 
   /* Do the debug-on-exit now, while arg_vector still exists.  */
-  if (backtrace_list->debug_on_exit)
-    tem = call_debugger (Fcons (Qexit, Fcons (tem, Qnil)));
-  /* Don't do it again when we return to eval.  */
-  backtrace_list->debug_on_exit = 0;
+  if (backtrace_debug_on_exit (specpdl_ptr - 1))
+    {
+      /* Don't do it again when we return to eval.  */
+      set_backtrace_debug_on_exit (specpdl_ptr - 1, false);
+      tem = call_debugger (Fcons (Qexit, Fcons (tem, Qnil)));
+    }
   SAFE_FREE ();
   return tem;
 }
@@ -2936,20 +2975,38 @@ DEFUN ("fetch-bytecode", Ffetch_bytecode, Sfetch_bytecode,
   return object;
 }
 
-static void
-grow_specpdl (void)
+/* Return true if SYMBOL currently has a let-binding
+   which was made in the buffer that is now current.  */
+
+bool
+let_shadows_buffer_binding_p (struct Lisp_Symbol *symbol)
 {
-  register ptrdiff_t count = SPECPDL_INDEX ();
-  ptrdiff_t max_size = min (max_specpdl_size, PTRDIFF_MAX);
-  if (max_size <= specpdl_size)
-    {
-      if (max_specpdl_size < 400)
-        max_size = max_specpdl_size = 400;
-      if (max_size <= specpdl_size)
-        signal_error ("Variable binding depth exceeds max-specpdl-size", Qnil);
-    }
-  specpdl = xpalloc (specpdl, &specpdl_size, 1, max_size, sizeof *specpdl);
-  specpdl_ptr = specpdl + count;
+  struct specbinding *p;
+  Lisp_Object buf = Fcurrent_buffer ();
+
+  for (p = specpdl_ptr; p > specpdl; )
+    if ((--p)->kind > SPECPDL_LET)
+      {
+        struct Lisp_Symbol *let_bound_symbol = XSYMBOL (specpdl_symbol (p));
+        eassert (let_bound_symbol->redirect != SYMBOL_VARALIAS);
+        if (symbol == let_bound_symbol
+            && EQ (specpdl_where (p), buf))
+          return 1;
+      }
+
+  return 0;
+}
+
+bool
+let_shadows_global_binding_p (Lisp_Object symbol)
+{
+  struct specbinding *p;
+
+  for (p = specpdl_ptr; p > specpdl; )
+    if ((--p)->kind >= SPECPDL_LET && EQ (specpdl_symbol (p), symbol))
+      return 1;
+
+  return 0;
 }
 
 /* `specpdl_ptr->symbol' is a field which describes which variable is
@@ -2985,9 +3042,9 @@ specbind (Lisp_Object symbol, Lisp_Object value)
     case SYMBOL_PLAINVAL:
       /* The most common case is that of a non-constant symbol with a
          trivial value.  Make that as fast as we can.  */
-      set_specpdl_symbol (symbol);
-      set_specpdl_old_value (SYMBOL_VAL (sym));
-      specpdl_ptr->func = NULL;
+      specpdl_ptr->kind = SPECPDL_LET;
+      specpdl_ptr->v.let.symbol = symbol;
+      specpdl_ptr->v.let.old_value = SYMBOL_VAL (sym);
       ++specpdl_ptr;
       if (!sym->constant)
         SET_SYMBOL_VAL (sym, value);
@@ -3000,59 +3057,36 @@ specbind (Lisp_Object symbol, Lisp_Object value)
     case SYMBOL_FORWARDED:
       {
         Lisp_Object ovalue = find_symbol_value (symbol);
-        specpdl_ptr->func = 0;
-        set_specpdl_old_value (ovalue);
+        specpdl_ptr->kind = SPECPDL_LET_LOCAL;
+        specpdl_ptr->v.let.symbol = symbol;
+        specpdl_ptr->v.let.old_value = ovalue;
+        specpdl_ptr->v.let.where = Fcurrent_buffer ();
 
         eassert (sym->redirect != SYMBOL_LOCALIZED
-                 || (EQ (SYMBOL_BLV (sym)->where,
-                         SYMBOL_BLV (sym)->frame_local ?
-                         Fselected_frame () : Fcurrent_buffer ())));
+                 || (EQ (SYMBOL_BLV (sym)->where, Fcurrent_buffer ())));
 
-        if (sym->redirect == SYMBOL_LOCALIZED
-            || BUFFER_OBJFWDP (SYMBOL_FWD (sym)))
+        if (sym->redirect == SYMBOL_LOCALIZED)
+          {
+            if (!blv_found (SYMBOL_BLV (sym)))
+              specpdl_ptr->kind = SPECPDL_LET_DEFAULT;
+          }
+        else if (BUFFER_OBJFWDP (SYMBOL_FWD (sym)))
           {
-            Lisp_Object where, cur_buf = Fcurrent_buffer ();
-
-            /* For a local variable, record both the symbol and which
-               buffer's or frame's value we are saving.  */
-            if (!NILP (Flocal_variable_p (symbol, Qnil)))
-              {
-                eassert (sym->redirect != SYMBOL_LOCALIZED
-                         || (blv_found (SYMBOL_BLV (sym))
-                             && EQ (cur_buf, SYMBOL_BLV (sym)->where)));
-                where = cur_buf;
-              }
-            else if (sym->redirect == SYMBOL_LOCALIZED
-                     && blv_found (SYMBOL_BLV (sym)))
-              where = SYMBOL_BLV (sym)->where;
-            else
-              where = Qnil;
-
-            /* We're not using the `unused' slot in the specbinding
-               structure because this would mean we have to do more
-               work for simple variables.  */
-            /* FIXME: The third value `current_buffer' is only used in
-               let_shadows_buffer_binding_p which is itself only used
-               in set_internal for local_if_set.  */
-            eassert (NILP (where) || EQ (where, cur_buf));
-            set_specpdl_symbol (Fcons (symbol, Fcons (where, cur_buf)));
-
             /* If SYMBOL is a per-buffer variable which doesn't have a
                buffer-local value here, make the `let' change the global
                value by changing the value of SYMBOL in all buffers not
                having their own value.  This is consistent with what
                happens with other buffer-local variables.  */
-            if (NILP (where)
-                && sym->redirect == SYMBOL_FORWARDED)
+            if (NILP (Flocal_variable_p (symbol, Qnil)))
               {
-                eassert (BUFFER_OBJFWDP (SYMBOL_FWD (sym)));
+                specpdl_ptr->kind = SPECPDL_LET_DEFAULT;
                 ++specpdl_ptr;
                 Fset_default (symbol, value);
                 return;
               }
           }
         else
-          set_specpdl_symbol (symbol);
+          specpdl_ptr->kind = SPECPDL_LET;
 
         specpdl_ptr++;
         set_internal (symbol, value, Qnil, 1);
@@ -3067,9 +3101,9 @@ record_unwind_protect (Lisp_Object (*function) (Lisp_Object), Lisp_Object arg)
 {
   if (specpdl_ptr == specpdl + specpdl_size)
     grow_specpdl ();
-  specpdl_ptr->func = function;
-  set_specpdl_symbol (Qnil);
-  set_specpdl_old_value (arg);
+  specpdl_ptr->kind = SPECPDL_UNWIND;
+  specpdl_ptr->v.unwind.func = function;
+  specpdl_ptr->v.unwind.arg = arg;
   specpdl_ptr++;
 }
 
@@ -3093,41 +3127,50 @@ unbind_to (ptrdiff_t count, Lisp_Object value)
       struct specbinding this_binding;
       this_binding = *--specpdl_ptr;
 
-      if (this_binding.func != 0)
-        (*this_binding.func) (this_binding.old_value);
-      /* If the symbol is a list, it is really (SYMBOL WHERE
-         . CURRENT-BUFFER) where WHERE is either nil, a buffer, or a
-         frame.  If WHERE is a buffer or frame, this indicates we
-         bound a variable that had a buffer-local or frame-local
-         binding.  WHERE nil means that the variable had the default
-         value when it was bound.  CURRENT-BUFFER is the buffer that
-         was current when the variable was bound.  */
-      else if (CONSP (this_binding.symbol))
+      switch (this_binding.kind)
         {
-          Lisp_Object symbol, where;
-
-          symbol = XCAR (this_binding.symbol);
-          where = XCAR (XCDR (this_binding.symbol));
-
-          if (NILP (where))
-            Fset_default (symbol, this_binding.old_value);
-          /* If `where' is non-nil, reset the value in the appropriate
-             local binding, but only if that binding still exists.  */
-          else if (BUFFERP (where)
-                   ? !NILP (Flocal_variable_p (symbol, where))
-                   : !NILP (Fassq (symbol, XFRAME (where)->param_alist)))
-            set_internal (symbol, this_binding.old_value, where, 1);
+        case SPECPDL_UNWIND:
+          (*specpdl_func (&this_binding)) (specpdl_arg (&this_binding));
+          break;
+        case SPECPDL_LET:
+          /* If variable has a trivial value (no forwarding), we can
+             just set it.  No need to check for constant symbols here,
+             since that was already done by specbind.  */
+          if (XSYMBOL (specpdl_symbol (&this_binding))->redirect
+              == SYMBOL_PLAINVAL)
+            SET_SYMBOL_VAL (XSYMBOL (specpdl_symbol (&this_binding)),
+                            specpdl_old_value (&this_binding));
+          else
+            /* NOTE: we only ever come here if make_local_foo was used for
+               the first time on this var within this let.  */
+            Fset_default (specpdl_symbol (&this_binding),
+                          specpdl_old_value (&this_binding));
+          break;
+        case SPECPDL_BACKTRACE:
+          break;
+        case SPECPDL_LET_LOCAL:
+        case SPECPDL_LET_DEFAULT:
+          { /* If the symbol is a list, it is really (SYMBOL WHERE
+             . CURRENT-BUFFER) where WHERE is either nil, a buffer, or a
+             frame.  If WHERE is a buffer or frame, this indicates we
+             bound a variable that had a buffer-local or frame-local
+             binding.  WHERE nil means that the variable had the default
+             value when it was bound.  CURRENT-BUFFER is the buffer that
+             was current when the variable was bound.  */
+            Lisp_Object symbol = specpdl_symbol (&this_binding);
+            Lisp_Object where = specpdl_where (&this_binding);
+            eassert (BUFFERP (where));
+
+            if (this_binding.kind == SPECPDL_LET_DEFAULT)
+              Fset_default (symbol, specpdl_old_value (&this_binding));
+            /* If this was a local binding, reset the value in the appropriate
+               buffer, but only if that buffer's binding still exists.  */
+            else if (!NILP (Flocal_variable_p (symbol, where)))
+              set_internal (symbol, specpdl_old_value (&this_binding),
+                            where, 1);
+          }
+          break;
         }
-      /* If variable has a trivial value (no forwarding), we can
-         just set it.  No need to check for constant symbols here,
-         since that was already done by specbind.  */
-      else if (XSYMBOL (this_binding.symbol)->redirect == SYMBOL_PLAINVAL)
-        SET_SYMBOL_VAL (XSYMBOL (this_binding.symbol),
-                        this_binding.old_value);
-      else
-        /* NOTE: we only ever come here if make_local_foo was used for
-           the first time on this var within this let.  */
-        Fset_default (this_binding.symbol, this_binding.old_value);
     }
 
   if (NILP (Vquit_flag) && !NILP (quitf))
@@ -3153,18 +3196,16 @@ DEFUN ("backtrace-debug", Fbacktrace_debug, Sbacktrace_debug, 2, 2, 0,
 The debugger is entered when that frame exits, if the flag is non-nil.  */)
   (Lisp_Object level, Lisp_Object flag)
 {
-  register struct backtrace *backlist = backtrace_list;
+  struct specbinding *pdl = backtrace_top ();
   register EMACS_INT i;
 
   CHECK_NUMBER (level);
 
-  for (i = 0; backlist && i < XINT (level); i++)
-    {
-      backlist = backlist->next;
-    }
+  for (i = 0; backtrace_p (pdl) && i < XINT (level); i++)
+    pdl = backtrace_next (pdl);
 
-  if (backlist)
-    backlist->debug_on_exit = !NILP (flag);
+  if (backtrace_p (pdl))
+    set_backtrace_debug_on_exit (pdl, !NILP (flag));
 
   return flag;
 }
@@ -3174,58 +3215,41 @@ DEFUN ("backtrace", Fbacktrace, Sbacktrace, 0, 0, "",
 Output stream used is value of `standard-output'.  */)
   (void)
 {
-  register struct backtrace *backlist = backtrace_list;
-  Lisp_Object tail;
+  struct specbinding *pdl = backtrace_top ();
   Lisp_Object tem;
-  struct gcpro gcpro1;
   Lisp_Object old_print_level = Vprint_level;
 
   if (NILP (Vprint_level))
     XSETFASTINT (Vprint_level, 8);
 
-  tail = Qnil;
-  GCPRO1 (tail);
-
-  while (backlist)
+  while (backtrace_p (pdl))
     {
-      write_string (backlist->debug_on_exit ? "* " : "  ", 2);
-      if (backlist->nargs == UNEVALLED)
+      write_string (backtrace_debug_on_exit (pdl) ? "* " : "  ", 2);
+      if (backtrace_nargs (pdl) == UNEVALLED)
         {
-          Fprin1 (Fcons (backlist->function, *backlist->args), Qnil);
+          Fprin1 (Fcons (backtrace_function (pdl), *backtrace_args (pdl)),
+                  Qnil);
           write_string ("\n", -1);
         }
       else
         {
-          tem = backlist->function;
+          tem = backtrace_function (pdl);
           Fprin1 (tem, Qnil);   /* This can QUIT.  */
           write_string ("(", -1);
-          if (backlist->nargs == MANY)
-            {                   /* FIXME: Can this happen?  */
-              bool later_arg = 0;
-              for (tail = *backlist->args; !NILP (tail); tail = Fcdr (tail))
-                {
-                  if (later_arg)
-                    write_string (" ", -1);
-                  Fprin1 (Fcar (tail), Qnil);
-                  later_arg = 1;
-                }
-            }
-          else
-            {
-              ptrdiff_t i;
-              for (i = 0; i < backlist->nargs; i++)
-                {
-                  if (i) write_string (" ", -1);
-                  Fprin1 (backlist->args[i], Qnil);
-                }
-            }
+          {
+            ptrdiff_t i;
+            for (i = 0; i < backtrace_nargs (pdl); i++)
+              {
+                if (i) write_string (" ", -1);
+                Fprin1 (backtrace_args (pdl)[i], Qnil);
+              }
+          }
           write_string (")\n", -1);
         }
-      backlist = backlist->next;
+      pdl = backtrace_next (pdl);
     }
 
   Vprint_level = old_print_level;
-  UNGCPRO;
   return Qnil;
 }
 
@@ -3241,53 +3265,84 @@ or a lambda expression for macro calls.
 If NFRAMES is more than the number of frames, the value is nil.  */)
   (Lisp_Object nframes)
 {
-  register struct backtrace *backlist = backtrace_list;
+  struct specbinding *pdl = backtrace_top ();
   register EMACS_INT i;
-  Lisp_Object tem;
 
   CHECK_NATNUM (nframes);
 
   /* Find the frame requested.  */
-  for (i = 0; backlist && i < XFASTINT (nframes); i++)
-    backlist = backlist->next;
+  for (i = 0; backtrace_p (pdl) && i < XFASTINT (nframes); i++)
+    pdl = backtrace_next (pdl);
 
-  if (!backlist)
+  if (!backtrace_p (pdl))
     return Qnil;
-  if (backlist->nargs == UNEVALLED)
-    return Fcons (Qnil, Fcons (backlist->function, *backlist->args));
+  if (backtrace_nargs (pdl) == UNEVALLED)
+    return Fcons (Qnil,
+                  Fcons (backtrace_function (pdl), *backtrace_args (pdl)));
   else
     {
-      if (backlist->nargs == MANY) /* FIXME: Can this happen?  */
-        tem = *backlist->args;
-      else
-        tem = Flist (backlist->nargs, backlist->args);
+      Lisp_Object tem = Flist (backtrace_nargs (pdl), backtrace_args (pdl));
 
-      return Fcons (Qt, Fcons (backlist->function, tem));
+      return Fcons (Qt, Fcons (backtrace_function (pdl), tem));
     }
 }
 
 
-#if BYTE_MARK_STACK
 void
-mark_backtrace (void)
+mark_specpdl (void)
 {
-  register struct backtrace *backlist;
-  ptrdiff_t i;
-
-  for (backlist = backtrace_list; backlist; backlist = backlist->next)
+  struct specbinding *pdl;
+  for (pdl = specpdl; pdl != specpdl_ptr; pdl++)
     {
-      mark_object (backlist->function);
+      switch (pdl->kind)
+        {
+        case SPECPDL_UNWIND:
+          mark_object (specpdl_arg (pdl));
+          break;
+        case SPECPDL_BACKTRACE:
+          {
+            ptrdiff_t nargs = backtrace_nargs (pdl);
+            mark_object (backtrace_function (pdl));
+            if (nargs == UNEVALLED)
+              nargs = 1;
+            while (nargs--)
+              mark_object (backtrace_args (pdl)[nargs]);
+          }
+          break;
+        case SPECPDL_LET_DEFAULT:
+        case SPECPDL_LET_LOCAL:
+          mark_object (specpdl_where (pdl));
+        case SPECPDL_LET:
+          mark_object (specpdl_symbol (pdl));
+          mark_object (specpdl_old_value (pdl));
+        }
+    }
+}
+
+void
+get_backtrace (Lisp_Object array)
+{
+  struct specbinding *pdl = backtrace_next (backtrace_top ());
+  ptrdiff_t i = 0, asize = ASIZE (array);
 
-      if (backlist->nargs == UNEVALLED
-          || backlist->nargs == MANY) /* FIXME: Can this happen?  */
-        i = 1;
+  /* Copy the backtrace contents into working memory.  */
+  for (; i < asize; i++)
+    {
+      if (backtrace_p (pdl))
+        {
+          ASET (array, i, backtrace_function (pdl));
+          pdl = backtrace_next (pdl);
+        }
       else
-        i = backlist->nargs;
-      while (i--)
-        mark_object (backlist->args[i]);
+        ASET (array, i, Qnil);
     }
 }
-#endif
+
+Lisp_Object backtrace_top_function (void)
+{
+  struct specbinding *pdl = backtrace_top ();
+  return (backtrace_p (pdl) ? backtrace_function (pdl) : Qnil);
+}
 
 void
 syms_of_eval (void)
diff --git a/src/frame.c b/src/frame.c
index e88432b9802..a207ef690da 100644
--- a/src/frame.c
+++ b/src/frame.c
@@ -114,7 +114,7 @@ Lisp_Object Qface_set_after_frame_default;
 
 static Lisp_Object Qdelete_frame_functions;
 
-Lisp_Object Qgeometry, Qworkarea, Qmm_size, Qframes, Qsource;
+static Lisp_Object Qgeometry, Qworkarea, Qmm_size, Qframes, Qsource;
 
 #ifdef HAVE_WINDOW_SYSTEM
 static void x_report_frame_params (struct frame *, Lisp_Object *);
@@ -167,7 +167,7 @@ struct frame *
 decode_window_system_frame (Lisp_Object frame)
 {
   struct frame *f = decode_live_frame (frame);
-  
+
   if (!window_system_available (f))
     error ("Window system frame should be used");
   return f;
@@ -4138,6 +4138,8 @@ selected frame.  This is useful when `make-pointer-invisible' is set.  */)
 
 #ifdef HAVE_WINDOW_SYSTEM
 
+# if (defined HAVE_NS \
+      || (!defined USE_GTK && (defined HAVE_XINERAMA || defined HAVE_XRANDR)))
 void
 free_monitors (struct MonitorInfo *monitors, int n_monitors)
 {
@@ -4146,6 +4148,7 @@ free_monitors (struct MonitorInfo *monitors, int n_monitors)
     xfree (monitors[i].name);
   xfree (monitors);
 }
+# endif
 
 Lisp_Object
 make_monitor_attribute_list (struct MonitorInfo *monitors,
diff --git a/src/frame.h b/src/frame.h
index 12aa48b2d92..31d3e73c3c3 100644
--- a/src/frame.h
+++ b/src/frame.h
@@ -1198,8 +1198,6 @@ extern Lisp_Object Qdisplay;
 
 extern Lisp_Object Qrun_hook_with_args;
 
-extern Lisp_Object Qgeometry, Qworkarea, Qmm_size, Qframes, Qsource;
-
 #ifdef HAVE_WINDOW_SYSTEM
 
 /* The class of this X application.  */
diff --git a/src/gfilenotify.c b/src/gfilenotify.c
new file mode 100644
index 00000000000..4ccc430d815
--- /dev/null
+++ b/src/gfilenotify.c
@@ -0,0 +1,266 @@
+/* Filesystem notifications support with glib API.
+   Copyright (C) 2013 Free Software Foundation, Inc.
+
+This file is part of GNU Emacs.
+
+GNU Emacs is free software: you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation, either version 3 of the License, or
+(at your option) any later version.
+
+GNU Emacs is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.  */
+
+#include <config.h>
+
+#ifdef HAVE_GFILENOTIFY
+#include <stdio.h>
+#include <gio/gio.h>
+#include "lisp.h"
+#include "coding.h"
+#include "frame.h"
+#include "termhooks.h"
+#include "keyboard.h"
+#include "process.h"
+
+
+/* Subroutines.  */
+static Lisp_Object Qgfile_add_watch;
+static Lisp_Object Qgfile_rm_watch;
+
+/* Filter objects.  */
+static Lisp_Object Qwatch_mounts;      /* G_FILE_MONITOR_WATCH_MOUNTS  */
+static Lisp_Object Qsend_moved;        /* G_FILE_MONITOR_SEND_MOVED  */
+
+/* Event types.  */
+static Lisp_Object Qchanged;           /* G_FILE_MONITOR_EVENT_CHANGED  */
+static Lisp_Object Qchanges_done_hint; /* G_FILE_MONITOR_EVENT_CHANGES_DONE_HINT  */
+static Lisp_Object Qdeleted;           /* G_FILE_MONITOR_EVENT_DELETED  */
+static Lisp_Object Qcreated;           /* G_FILE_MONITOR_EVENT_CREATED  */
+static Lisp_Object Qattribute_changed; /* G_FILE_MONITOR_EVENT_ATTRIBUTE_CHANGED  */
+static Lisp_Object Qpre_unmount;       /* G_FILE_MONITOR_EVENT_PRE_UNMOUNT  */
+static Lisp_Object Qunmounted;         /* G_FILE_MONITOR_EVENT_UNMOUNTED  */
+static Lisp_Object Qmoved;             /* G_FILE_MONITOR_EVENT_MOVED  */
+
+static Lisp_Object watch_list;
+
+/* This is the callback function for arriving signals from
+   g_file_monitor.  It shall create a Lisp event, and put it into
+   Emacs input queue.  */
+static gboolean
+dir_monitor_callback (GFileMonitor* monitor,
+                      GFile* file,
+                      GFile* other_file,
+                      GFileMonitorEvent event_type,
+                      gpointer user_data)
+{
+  Lisp_Object symbol, watch_object;
+  char *name = g_file_get_parse_name (file);
+  char *oname = other_file ? g_file_get_parse_name (other_file) : NULL;
+
+  /* Determine event symbol.  */
+  switch (event_type)
+    {
+    case G_FILE_MONITOR_EVENT_CHANGED:
+      symbol = Qchanged;
+      break;
+    case G_FILE_MONITOR_EVENT_CHANGES_DONE_HINT:
+      symbol = Qchanges_done_hint;
+      break;
+    case G_FILE_MONITOR_EVENT_DELETED:
+      symbol = Qdeleted;
+      break;
+    case G_FILE_MONITOR_EVENT_CREATED:
+      symbol = Qcreated;
+      break;
+    case G_FILE_MONITOR_EVENT_ATTRIBUTE_CHANGED:
+      symbol = Qattribute_changed;
+      break;
+    case G_FILE_MONITOR_EVENT_PRE_UNMOUNT:
+      symbol = Qpre_unmount;
+      break;
+    case G_FILE_MONITOR_EVENT_UNMOUNTED:
+      symbol = Qunmounted;
+      break;
+    case G_FILE_MONITOR_EVENT_MOVED:
+      symbol = Qmoved;
+      break;
+    default:
+      goto cleanup;
+    }
+
+  /* Determine callback function.  */
+  watch_object = Fassoc (XIL ((EMACS_INT) monitor), watch_list);
+
+  if (FUNCTIONP (CDR_SAFE (watch_object)))
+    {
+      /* Construct an event.  */
+      struct input_event event;
+      EVENT_INIT (event);
+      event.kind = FILE_NOTIFY_EVENT;
+      event.frame_or_window = Qnil;
+      event.arg = oname
+        ? list2 (list4 (XIL ((EMACS_INT) monitor), symbol,
+                        build_string (name), build_string (oname)),
+                 CDR_SAFE (watch_object))
+        : list2 (list3 (XIL ((EMACS_INT) monitor), symbol, build_string (name)),
+                 CDR_SAFE (watch_object));
+
+      /* Store it into the input event queue.  */
+      kbd_buffer_store_event (&event);
+    }
+
+  /* Cleanup.  */
+ cleanup:
+  g_free (name);
+  g_free (oname);
+
+  return TRUE;
+}
+
+DEFUN ("gfile-add-watch", Fgfile_add_watch, Sgfile_add_watch, 3, 3, 0,
+       doc: /* Add a watch for filesystem events pertaining to FILE.
+
+This arranges for filesystem events pertaining to FILE to be reported
+to Emacs.  Use `gfile-rm-watch' to cancel the watch.
+
+Value is a descriptor for the added watch.  If the file cannot be
+watched for some reason, this function signals a `file-error' error.
+
+FLAGS is a list of conditions to set what will be watched for.  It can
+include the following symbols:
+
+  'watch-mounts' -- watch for mount events
+  'send-moved'   -- pair 'deleted' and 'created' events caused by file
+                    renames (moves) and send a single 'event-moved'
+                    event instead
+
+When any event happens, Emacs will call the CALLBACK function passing
+it a single argument EVENT, which is of the form
+
+  (DESCRIPTOR ACTION FILE [FILE1])
+
+DESCRIPTOR is the same object as the one returned by this function.
+ACTION is the description of the event.  It could be any one of the
+following:
+
+  'changed'           -- FILE has changed
+  'changes-done-hint' -- a hint that this was probably the last change
+                         in a set of changes
+  'deleted'           -- FILE was deleted
+  'created'           -- FILE was created
+  'attribute-changed' -- a FILE attribute was changed
+  'pre-unmount'       -- the FILE location will soon be unmounted
+  'unmounted'         -- the FILE location was unmounted
+  'moved'             -- FILE was moved to FILE1
+
+FILE is the name of the file whose event is being reported.  FILE1
+will be reported only in case of the 'moved' event.  */)
+  (Lisp_Object file, Lisp_Object flags, Lisp_Object callback)
+{
+  Lisp_Object watch_descriptor, watch_object;
+  GFile *gfile;
+  GFileMonitor* monitor;
+  GFileMonitorFlags gflags = G_FILE_MONITOR_NONE;
+
+  /* Check parameters.  */
+  CHECK_STRING (file);
+  file = Fdirectory_file_name (Fexpand_file_name (file, Qnil));
+  if (NILP (Ffile_exists_p (file)))
+    report_file_error ("File does not exists", Fcons (file, Qnil));
+
+  CHECK_LIST (flags);
+
+  if (!FUNCTIONP (callback))
+    wrong_type_argument (Qinvalid_function, callback);
+
+  /* Create GFile name.  */
+  gfile = g_file_new_for_path (SSDATA (ENCODE_FILE (file)));
+
+  /* Assemble flags.  */
+  if (!NILP (Fmember (Qwatch_mounts, flags)))
+    gflags |= G_FILE_MONITOR_WATCH_MOUNTS;
+  if (!NILP (Fmember (Qsend_moved, flags)))
+    gflags |= G_FILE_MONITOR_SEND_MOVED;
+
+  /* Enable watch.  */
+  monitor = g_file_monitor (gfile, gflags, NULL, NULL);
+  if (monitor != NULL)
+    g_signal_connect (monitor, "changed",
+                      (GCallback) dir_monitor_callback, NULL);
+  else
+    report_file_error ("Cannot watch file", Fcons (file, Qnil));
+
+  /* Store watch object in watch list.  */
+  watch_descriptor = XIL ((EMACS_INT) monitor);
+  watch_object = Fcons (watch_descriptor, callback);
+  watch_list = Fcons (watch_object, watch_list);
+
+  return watch_descriptor;
+}
+
+DEFUN ("gfile-rm-watch", Fgfile_rm_watch, Sgfile_rm_watch, 1, 1, 0,
+       doc: /* Remove an existing WATCH-DESCRIPTOR.
+
+WATCH-DESCRIPTOR should be an object returned by `gfile-add-watch'.  */)
+     (Lisp_Object watch_descriptor)
+{
+  Lisp_Object watch_object;
+  GFileMonitor *monitor = (GFileMonitor *) XLI (watch_descriptor);
+
+  watch_object = Fassoc (watch_descriptor, watch_list);
+  if (NILP (watch_object))
+    report_file_error ("Not a watch descriptor",
+                       Fcons (watch_descriptor, Qnil));
+
+  if (!g_file_monitor_cancel (monitor))
+    report_file_error ("Could not rm watch",
+                       Fcons (watch_descriptor, Qnil));
+
+  /* Remove watch descriptor from watch list. */
+  watch_list = Fdelete (watch_object, watch_list);
+
+  /* Cleanup.  */
+  g_object_unref (monitor);
+
+  return Qt;
+}
+
+
+void
+syms_of_gfilenotify (void)
+{
+
+  g_type_init ();
+
+  DEFSYM (Qgfile_add_watch, "gfile-add-watch");
+  defsubr (&Sgfile_add_watch);
+
+  DEFSYM (Qgfile_rm_watch, "gfile-rm-watch");
+  defsubr (&Sgfile_rm_watch);
+
+  DEFSYM (Qwatch_mounts, "watch-mounts");
+  DEFSYM (Qsend_moved, "send-moved");
+  DEFSYM (Qchanged, "changed");
+  DEFSYM (Qchanges_done_hint, "changes-done-hint");
+  DEFSYM (Qdeleted, "deleted");
+  DEFSYM (Qcreated, "created");
+  DEFSYM (Qattribute_changed, "attribute-changed");
+  DEFSYM (Qpre_unmount, "pre-unmount");
+  DEFSYM (Qunmounted, "unmounted");
+  DEFSYM (Qmoved, "moved");
+
+  /* Initialize internal objects.  */
+  watch_list = Qnil;
+  staticpro (&watch_list);
+
+  Fprovide (intern_c_string ("gfilenotify"), Qnil);
+
+}
+
+#endif /* HAVE_GFILENOTIFY  */
diff --git a/src/keyboard.c b/src/keyboard.c
index 0a7577b859e..8dd109d252d 100644
--- a/src/keyboard.c
+++ b/src/keyboard.c
@@ -308,18 +308,15 @@ static Lisp_Object Qfunction_key;
 Lisp_Object Qmouse_click;
 #ifdef HAVE_NTGUI
 Lisp_Object Qlanguage_change;
-#ifdef WINDOWSNT
-Lisp_Object Qfile_w32notify;
-#endif
 #endif
 static Lisp_Object Qdrag_n_drop;
 static Lisp_Object Qsave_session;
 #ifdef HAVE_DBUS
 static Lisp_Object Qdbus_event;
 #endif
-#ifdef HAVE_INOTIFY
-static Lisp_Object Qfile_inotify;
-#endif /* HAVE_INOTIFY */
+#ifdef USE_FILE_NOTIFY
+static Lisp_Object Qfile_notify;
+#endif /* USE_FILE_NOTIFY */
 static Lisp_Object Qconfig_changed_event;
 
 /* Lisp_Object Qmouse_movement; - also an event header */
@@ -1885,7 +1882,7 @@ safe_run_hooks_error (Lisp_Object error_data)
     = CONSP (Vinhibit_quit) ? XCAR (Vinhibit_quit) : Vinhibit_quit;
   Lisp_Object fun = CONSP (Vinhibit_quit) ? XCDR (Vinhibit_quit) : Qnil;
   Lisp_Object args[4];
-  args[0] = build_string ("Error in %s (%s): %S");
+  args[0] = build_string ("Error in %s (%S): %S");
   args[1] = hook;
   args[2] = fun;
   args[3] = error_data;
@@ -4013,18 +4010,22 @@ kbd_buffer_get_event (KBOARD **kbp,
           kbd_fetch_ptr = event + 1;
         }
 #endif
-#ifdef WINDOWSNT
+#ifdef USE_FILE_NOTIFY
       else if (event->kind == FILE_NOTIFY_EVENT)
         {
+#ifdef HAVE_W32NOTIFY
           /* Make an event (file-notify (DESCRIPTOR ACTION FILE) CALLBACK).  */
-          obj = Fcons (Qfile_w32notify,
+          obj = Fcons (Qfile_notify,
                        list2 (list3 (make_number (event->code),
                                      XCAR (event->arg),
                                      XCDR (event->arg)),
                               event->frame_or_window));
+#else
+          obj = make_lispy_event (event);
+#endif
           kbd_fetch_ptr = event + 1;
         }
-#endif
+#endif /* USE_FILE_NOTIFY */
       else if (event->kind == SAVE_SESSION_EVENT)
         {
           obj = Fcons (Qsave_session, Fcons (event->arg, Qnil));
@@ -4082,13 +4083,6 @@ kbd_buffer_get_event (KBOARD **kbp,
           kbd_fetch_ptr = event + 1;
         }
 #endif
-#ifdef HAVE_INOTIFY
-      else if (event->kind == FILE_NOTIFY_EVENT)
-        {
-          obj = make_lispy_event (event);
-          kbd_fetch_ptr = event + 1;
-        }
-#endif
       else if (event->kind == CONFIG_CHANGED_EVENT)
         {
           obj = make_lispy_event (event);
@@ -5991,12 +5985,12 @@ make_lispy_event (struct input_event *event)
       }
 #endif /* HAVE_DBUS */
 
-#ifdef HAVE_INOTIFY
+#if defined HAVE_GFILENOTIFY || defined HAVE_INOTIFY
     case FILE_NOTIFY_EVENT:
       {
-        return Fcons (Qfile_inotify, event->arg);
+        return Fcons (Qfile_notify, event->arg);
       }
-#endif /* HAVE_INOTIFY */
+#endif /* defined HAVE_GFILENOTIFY || defined HAVE_INOTIFY */
 
     case CONFIG_CHANGED_EVENT:
         return Fcons (Qconfig_changed_event,
@@ -11006,17 +11000,13 @@ syms_of_keyboard (void)
   DEFSYM (Qlanguage_change, "language-change");
 #endif
 
-#ifdef WINDOWSNT
-  DEFSYM (Qfile_w32notify, "file-w32notify");
-#endif
-
 #ifdef HAVE_DBUS
   DEFSYM (Qdbus_event, "dbus-event");
 #endif
 
-#ifdef HAVE_INOTIFY
-  DEFSYM (Qfile_inotify, "file-inotify");
-#endif /* HAVE_INOTIFY */
+#ifdef USE_FILE_NOTIFY
+  DEFSYM (Qfile_notify, "file-notify");
+#endif /* USE_FILE_NOTIFY */
 
   DEFSYM (QCenable, ":enable");
   DEFSYM (QCvisible, ":visible");
@@ -11762,20 +11752,18 @@ keys_of_keyboard (void)
                             "dbus-handle-event");
 #endif
 
-#ifdef HAVE_INOTIFY
-  /* Define a special event which is raised for inotify callback
+#ifdef USE_FILE_NOTIFY
+  /* Define a special event which is raised for notification callback
      functions.  */
-  initial_define_lispy_key (Vspecial_event_map, "file-inotify",
-                            "inotify-handle-event");
-#endif /* HAVE_INOTIFY */
+  initial_define_lispy_key (Vspecial_event_map, "file-notify",
+                            "file-notify-handle-event");
+#endif /* USE_FILE_NOTIFY */
 
   initial_define_lispy_key (Vspecial_event_map, "config-changed-event",
                             "ignore");
 #if defined (WINDOWSNT)
   initial_define_lispy_key (Vspecial_event_map, "language-change",
                             "ignore");
-  initial_define_lispy_key (Vspecial_event_map, "file-w32notify",
-                            "w32notify-handle-event");
 #endif
 }
 
diff --git a/src/lisp.h b/src/lisp.h
index 79d32c90f73..517d0abbb61 100644
--- a/src/lisp.h
+++ b/src/lisp.h
@@ -73,6 +73,7 @@ enum
     BITS_PER_SHORT     = CHAR_BIT * sizeof (short),
     BITS_PER_INT       = CHAR_BIT * sizeof (int),
     BITS_PER_LONG      = CHAR_BIT * sizeof (long int),
+    BITS_PER_PTRDIFF_T = CHAR_BIT * sizeof (ptrdiff_t),
     BITS_PER_EMACS_INT = CHAR_BIT * sizeof (EMACS_INT)
   };
 
@@ -2176,12 +2177,24 @@ typedef jmp_buf sys_jmp_buf;
 #endif
 
 
+/* Elisp uses several stacks:
+   - the C stack.
+   - the bytecode stack: used internally by the bytecode interpreter.
+     Allocated from the C stack.
+   - The specpdl stack: keeps track of active unwind-protect and
+     dynamic-let-bindings.  Allocated from the `specpdl' array, a manually
+     managed stack.
+   - The catch stack: keeps track of active catch tags.
+     Allocated on the C stack.  This is where the setmp data is kept.
+   - The handler stack: keeps track of active condition-case handlers.
+     Allocated on the C stack.  Every entry there also uses an entry in
+     the catch stack.  */
+
 /* Structure for recording Lisp call stack for backtrace purposes.  */
 
 /* The special binding stack holds the outer values of variables while
    they are bound by a function application or a let form, stores the
-   code to be executed for Lisp unwind-protect forms, and stores the C
-   functions to be called for record_unwind_protect.
+   code to be executed for unwind-protect forms.
 
    If func is non-zero, undoing this binding applies func to old_value;
       This implements record_unwind_protect.
@@ -2194,35 +2207,77 @@ typedef jmp_buf sys_jmp_buf;
    which means having bound a local value while CURRENT-BUFFER was active.
    If WHERE is nil this means we saw the default value when binding SYMBOL.
    WHERE being a buffer or frame means we saw a buffer-local or frame-local
-   value.  Other values of WHERE mean an internal error.  */
+   value.  Other values of WHERE mean an internal error.
+
+   NOTE: The specbinding struct is defined here, because SPECPDL_INDEX is
+   used all over the place, needs to be fast, and needs to know the size of
+   struct specbinding.  But only eval.c should access it.  */
 
 typedef Lisp_Object (*specbinding_func) (Lisp_Object);
 
+enum specbind_tag {
+  SPECPDL_UNWIND,               /* An unwind_protect function.  */
+  SPECPDL_BACKTRACE,            /* An element of the backtrace.  */
+  SPECPDL_LET,                  /* A plain and simple dynamic let-binding.  */
+  /* Tags greater than SPECPDL_LET must be "subkinds" of LET.  */
+  SPECPDL_LET_LOCAL,            /* A buffer-local let-binding.  */
+  SPECPDL_LET_DEFAULT           /* A global binding for a localized var.  */
+};
+
 struct specbinding
   {
-    Lisp_Object symbol, old_value;
-    specbinding_func func;
-    Lisp_Object unused;         /* Dividing by 16 is faster than by 12.  */
+    enum specbind_tag kind;
+    union {
+      struct {
+        Lisp_Object arg;
+        specbinding_func func;
+      } unwind;
+      struct {
+        /* `where' is not used in the case of SPECPDL_LET.  */
+        Lisp_Object symbol, old_value, where;
+      } let;
+      struct {
+        Lisp_Object function;
+        Lisp_Object *args;
+        ptrdiff_t nargs : BITS_PER_PTRDIFF_T - 1;
+        bool debug_on_exit : 1;
+      } bt;
+    } v;
   };
 
+LISP_INLINE Lisp_Object specpdl_symbol (struct specbinding *pdl)
+{ eassert (pdl->kind >= SPECPDL_LET); return pdl->v.let.symbol; }
+
+LISP_INLINE Lisp_Object specpdl_old_value (struct specbinding *pdl)
+{ eassert (pdl->kind >= SPECPDL_LET); return pdl->v.let.old_value; }
+
+LISP_INLINE Lisp_Object specpdl_where (struct specbinding *pdl)
+{ eassert (pdl->kind > SPECPDL_LET); return pdl->v.let.where; }
+
+LISP_INLINE Lisp_Object specpdl_arg (struct specbinding *pdl)
+{ eassert (pdl->kind == SPECPDL_UNWIND); return pdl->v.unwind.arg; }
+
+LISP_INLINE specbinding_func specpdl_func (struct specbinding *pdl)
+{ eassert (pdl->kind == SPECPDL_UNWIND); return pdl->v.unwind.func; }
+
+LISP_INLINE Lisp_Object backtrace_function (struct specbinding *pdl)
+{ eassert (pdl->kind == SPECPDL_BACKTRACE); return pdl->v.bt.function; }
+
+LISP_INLINE ptrdiff_t backtrace_nargs (struct specbinding *pdl)
+{ eassert (pdl->kind == SPECPDL_BACKTRACE); return pdl->v.bt.nargs; }
+
+LISP_INLINE Lisp_Object *backtrace_args (struct specbinding *pdl)
+{ eassert (pdl->kind == SPECPDL_BACKTRACE); return pdl->v.bt.args; }
+
+LISP_INLINE bool backtrace_debug_on_exit (struct specbinding *pdl)
+{ eassert (pdl->kind == SPECPDL_BACKTRACE); return pdl->v.bt.debug_on_exit; }
+
 extern struct specbinding *specpdl;
 extern struct specbinding *specpdl_ptr;
 extern ptrdiff_t specpdl_size;
 
 #define SPECPDL_INDEX() (specpdl_ptr - specpdl)
 
-struct backtrace
-{
-  struct backtrace *next;
-  Lisp_Object function;
-  Lisp_Object *args;    /* Points to vector of args.  */
-  ptrdiff_t nargs;      /* Length of vector.  */
-  /* Nonzero means call value of debugger when done with this operation.  */
-  unsigned int debug_on_exit : 1;
-};
-
-extern struct backtrace *backtrace_list;
-
 /* Everything needed to describe an active condition case.
 
    Members are volatile if their values need to survive _longjmp when
@@ -2277,9 +2332,10 @@ struct catchtag
   Lisp_Object tag;
   Lisp_Object volatile val;
   struct catchtag *volatile next;
+#if 1 /* GC_MARK_STACK == GC_MAKE_GCPROS_NOOPS, but they're defined later.  */
   struct gcpro *gcpro;
+#endif
   sys_jmp_buf jmp;
-  struct backtrace *backlist;
   struct handler *handlerlist;
   EMACS_INT lisp_eval_depth;
   ptrdiff_t volatile pdlcount;
@@ -3337,10 +3393,15 @@ extern Lisp_Object safe_call (ptrdiff_t, Lisp_Object, ...);
 extern Lisp_Object safe_call1 (Lisp_Object, Lisp_Object);
 extern Lisp_Object safe_call2 (Lisp_Object, Lisp_Object, Lisp_Object);
 extern void init_eval (void);
-#if BYTE_MARK_STACK
-extern void mark_backtrace (void);
-#endif
 extern void syms_of_eval (void);
+extern void record_in_backtrace (Lisp_Object function,
+                                 Lisp_Object *args, ptrdiff_t nargs);
+extern void mark_specpdl (void);
+extern void get_backtrace (Lisp_Object array);
+Lisp_Object backtrace_top_function (void);
+extern bool let_shadows_buffer_binding_p (struct Lisp_Symbol *symbol);
+extern bool let_shadows_global_binding_p (Lisp_Object symbol);
+
 
 /* Defined in editfns.c.  */
 extern Lisp_Object Qfield;
@@ -3723,9 +3784,9 @@ extern void syms_of_fontset (void);
 extern Lisp_Object Qfont_param;
 #endif
 
-#ifdef WINDOWSNT
-/* Defined on w32notify.c.  */
-extern void syms_of_w32notify (void);
+/* Defined in gfilenotify.c */
+#ifdef HAVE_GFILENOTIFY
+extern void syms_of_gfilenotify (void);
 #endif
 
 /* Defined in inotify.c */
@@ -3733,6 +3794,11 @@ extern void syms_of_w32notify (void);
 extern void syms_of_inotify (void);
 #endif
 
+#ifdef HAVE_W32NOTIFY
+/* Defined on w32notify.c.  */
+extern void syms_of_w32notify (void);
+#endif
+
 /* Defined in xfaces.c.  */
 extern Lisp_Object Qdefault, Qtool_bar, Qfringe;
 extern Lisp_Object Qheader_line, Qscroll_bar, Qcursor;
diff --git a/src/nsfns.m b/src/nsfns.m
index 1170472573e..94339183159 100644
--- a/src/nsfns.m
+++ b/src/nsfns.m
@@ -287,7 +287,7 @@ static void
 x_set_foreground_color (struct frame *f, Lisp_Object arg, Lisp_Object oldval)
 {
   NSColor *col;
-  CGFloat r, g, b, alpha;
+  EmacsCGFloat r, g, b, alpha;
 
   if (ns_lisp_to_color (arg, &col))
     {
@@ -319,7 +319,7 @@ x_set_background_color (struct frame *f, Lisp_Object arg, Lisp_Object oldval)
   struct face *face;
   NSColor *col;
   NSView *view = FRAME_NS_VIEW (f);
-  CGFloat r, g, b, alpha;
+  EmacsCGFloat r, g, b, alpha;
 
   if (ns_lisp_to_color (arg, &col))
     {
@@ -344,7 +344,7 @@ x_set_background_color (struct frame *f, Lisp_Object arg, Lisp_Object oldval)
     {
       [[view window] setBackgroundColor: col];
 
-      if (alpha != 1.0)
+      if (alpha != (EmacsCGFloat) 1.0)
           [[view window] setOpaque: NO];
       else
           [[view window] setOpaque: YES];
@@ -714,7 +714,7 @@ x_set_tool_bar_lines (struct frame *f, Lisp_Object value, Lisp_Object oldval)
 }
 
 
-void
+static void
 ns_implicitly_set_icon_type (struct frame *f)
 {
   Lisp_Object tem;
@@ -859,7 +859,7 @@ ns_cursor_type_to_lisp (int arg)
 }
 
 /* This is the same as the xfns.c definition.  */
-void
+static void
 x_set_cursor_type (FRAME_PTR f, Lisp_Object arg, Lisp_Object oldval)
 {
   set_frame_cursor_types (f, arg);
@@ -1082,7 +1082,6 @@ This function is an internal primitive--use `make-frame' instead.  */)
   struct ns_display_info *dpyinfo = NULL;
   Lisp_Object parent;
   struct kboard *kb;
-  Lisp_Object tfont, tfontsize;
   static int desc_ctr = 1;
 
   /* x_get_arg modifies parms.  */
@@ -1189,10 +1188,10 @@ This function is an internal primitive--use `make-frame' instead.  */)
   {
     /* use for default font name */
     id font = [NSFont userFixedPitchFontOfSize: -1.0]; /* default */
-    tfontsize = x_default_parameter (f, parms, Qfontsize,
+    x_default_parameter (f, parms, Qfontsize,
                                     make_number (0 /*(int)[font pointSize]*/),
                                     "fontSize", "FontSize", RES_TYPE_NUMBER);
-    tfont = x_default_parameter (f, parms, Qfont,
+    x_default_parameter (f, parms, Qfont,
                                  build_string ([[font fontName] UTF8String]),
                                  "font", "Font", RES_TYPE_STRING);
   }
@@ -1410,6 +1409,7 @@ Optional arg DIR_ONLY_P, if non-nil, means choose only directories.  */)
 {
   static id fileDelegate = nil;
   BOOL ret;
+  BOOL isSave = NILP (mustmatch) && NILP (dir_only_p);
   id panel;
   Lisp_Object fname;
 
@@ -1431,7 +1431,7 @@ Optional arg DIR_ONLY_P, if non-nil, means choose only directories.  */)
   if ([dirS characterAtIndex: 0] == '~')
     dirS = [dirS stringByExpandingTildeInPath];
 
-  panel = NILP (mustmatch) && NILP (dir_only_p) ?
+  panel = isSave ?
     (id)[EmacsSavePanel savePanel] : (id)[EmacsOpenPanel openPanel];
 
   [panel setTitle: promptS];
@@ -1446,7 +1446,7 @@ Optional arg DIR_ONLY_P, if non-nil, means choose only directories.  */)
       [panel setCanChooseDirectories: YES];
       [panel setCanChooseFiles: NO];
     }
-  else
+  else if (! isSave)
     {
       /* This is not quite what the documentation says, but it is compatible
          with the Gtk+ code.  Also, the menu entry says "Open File...".  */
@@ -1481,8 +1481,8 @@ Optional arg DIR_ONLY_P, if non-nil, means choose only directories.  */)
 
   if (ret)
     {
-      NSString *str = [panel getFilename];
-      if (! str) str = [panel getDirectory];
+      NSString *str = ns_filename_from_panel (panel);
+      if (! str) str = ns_directory_from_panel (panel);
       if (! str) ret = NO;
       else fname = build_string ([str UTF8String]);
     }
@@ -1909,7 +1909,9 @@ DEFUN ("ns-list-services", Fns_list_services, Sns_list_services, 0, 0, 0,
 #else
   Lisp_Object ret = Qnil;
   NSMenu *svcs;
+#ifdef NS_IMPL_COCOA
   id delegate;
+#endif
 
   check_window_system (NULL);
   svcs = [[NSMenu alloc] initWithTitle: @"Services"];
@@ -1992,15 +1994,9 @@ DEFUN ("ns-convert-utf8-nfd-to-nfc", Fns_convert_utf8_nfd_to_nfc,
 
   CHECK_STRING (str);
   utfStr = [NSString stringWithUTF8String: SSDATA (str)];
-  if (![utfStr respondsToSelector:
-                 @selector (precomposedStringWithCanonicalMapping)])
-    {
-      message1
-        ("Warning: ns-convert-utf8-nfd-to-nfc unsupported under GNUstep.\n");
-      return Qnil;
-    }
-  else
+#ifdef NS_IMPL_COCOA
     utfStr = [utfStr precomposedStringWithCanonicalMapping];
+#endif
   return build_string ([utfStr UTF8String]);
 }
 
@@ -2155,6 +2151,9 @@ x_set_scroll_bar_default_width (struct frame *f)
 }
 
 
+extern const char *x_get_string_resource (XrmDatabase, char *, char *);
+
+
 /* terms impl this instead of x-get-resource directly */
 const char *
 x_get_string_resource (XrmDatabase rdb, char *name, char *class)
@@ -2203,13 +2202,6 @@ x_pixel_height (struct frame *f)
 }
 
 
-int
-x_screen_planes (struct frame *f)
-{
-  return FRAME_NS_DISPLAY_INFO (f)->n_planes;
-}
-
-
 void
 x_sync (struct frame *f)
 {
@@ -2242,7 +2234,7 @@ DEFUN ("xw-color-values", Fxw_color_values, Sxw_color_values, 1, 2, 0,
      (Lisp_Object color, Lisp_Object frame)
 {
   NSColor * col;
-  CGFloat red, green, blue, alpha;
+  EmacsCGFloat red, green, blue, alpha;
 
   check_window_system (NULL);
   CHECK_STRING (color);
@@ -2434,11 +2426,10 @@ Internal use only, use `display-monitor-attributes-list' instead.  */)
       struct MonitorInfo *m = &monitors[i];
       NSRect fr = [s frame];
       NSRect vfr = [s visibleFrame];
-      NSDictionary *dict = [s deviceDescription];
-      NSValue *resval = [dict valueForKey:NSDeviceResolution];
       short y, vy;
 
 #ifdef NS_IMPL_COCOA
+      NSDictionary *dict = [s deviceDescription];
       NSNumber *nid = [dict objectForKey:@"NSScreenNumber"];
       CGDirectDisplayID did = [nid unsignedIntValue];
 #endif
@@ -2776,14 +2767,6 @@ handlePanelKeys (NSSavePanel *panel, NSEvent *theEvent)
   [NSApp stop: self];
 }
 #endif
-- (NSString *) getFilename
-{
-  return ns_filename_from_panel (self);
-}
-- (NSString *) getDirectory
-{
-  return ns_directory_from_panel (self);
-}
 
 - (BOOL)performKeyEquivalent:(NSEvent *)theEvent
 {
@@ -2807,8 +2790,8 @@ handlePanelKeys (NSSavePanel *panel, NSEvent *theEvent)
   [super ok: sender];
 
   // If not choosing directories, and Open is pressed on a directory, return.
-  if (! [self canChooseDirectories] && [self getDirectory] &&
-      ! [self getFilename])
+  if (! [self canChooseDirectories] && ns_directory_from_panel (self) &&
+      ! ns_filename_from_panel (self))
     return;
 
   panelOK = 1;
@@ -2821,14 +2804,6 @@ handlePanelKeys (NSSavePanel *panel, NSEvent *theEvent)
 }
 
 #endif
-- (NSString *) getFilename
-{
-  return ns_filename_from_panel (self);
-}
-- (NSString *) getDirectory
-{
-  return ns_directory_from_panel (self);
-}
 - (BOOL)performKeyEquivalent:(NSEvent *)theEvent
 {
   // NSOpenPanel inherits NSSavePanel, so passing self is OK.
diff --git a/src/nsfont.m b/src/nsfont.m
index 9ab369d1fcd..709f2cb0d86 100644
--- a/src/nsfont.m
+++ b/src/nsfont.m
@@ -119,7 +119,7 @@ ns_attribute_fvalue (NSFontDescriptor *fdesc, NSString *trait)
 {
     NSDictionary *tdict = [fdesc objectForKey: NSFontTraitsAttribute];
     NSNumber *val = [tdict objectForKey: trait];
-    return val == nil ? 0.0 : [val floatValue];
+    return val == nil ? 0.0F : [val floatValue];
 }
 
 
@@ -138,15 +138,15 @@ ns_spec_to_descriptor (Lisp_Object font_spec)
     /* add each attr in font_spec to fdAttrs.. */
     n = min (FONT_WEIGHT_NUMERIC (font_spec), 200);
     if (n != -1 && n != STYLE_REF)
-        [tdict setObject: [NSNumber numberWithFloat: (n - 100.0) / 100.0]
+        [tdict setObject: [NSNumber numberWithFloat: (n - 100.0F) / 100.0F]
                   forKey: NSFontWeightTrait];
     n = min (FONT_SLANT_NUMERIC (font_spec), 200);
     if (n != -1 && n != STYLE_REF)
-        [tdict setObject: [NSNumber numberWithFloat: (n - 100.0) / 100.0]
+        [tdict setObject: [NSNumber numberWithFloat: (n - 100.0F) / 100.0F]
                   forKey: NSFontSlantTrait];
     n = min (FONT_WIDTH_NUMERIC (font_spec), 200);
     if (n > -1 && (n > STYLE_REF + 10 || n < STYLE_REF - 10))
-        [tdict setObject: [NSNumber numberWithFloat: (n - 100.0) / 100.0]
+        [tdict setObject: [NSNumber numberWithFloat: (n - 100.0F) / 100.0F]
                   forKey: NSFontWidthTrait];
     if ([tdict count] > 0)
         [fdAttrs setObject: tdict forKey: NSFontTraitsAttribute];
@@ -240,10 +240,10 @@ ns_fallback_entity (void)
 
 
 /* Utility: get width of a char c in screen font SFONT */
-static float
+static CGFloat
 ns_char_width (NSFont *sfont, int c)
 {
-  float w = -1.0;
+  CGFloat w = -1.0;
   NSString *cstr = [NSString stringWithFormat: @"%c", c];
 
 #ifdef NS_IMPL_COCOA
@@ -269,7 +269,7 @@ static NSString *ascii_printable;
 static int
 ns_ascii_average_width (NSFont *sfont)
 {
-  float w = -1.0;
+  CGFloat w = -1.0;
 
   if (!ascii_printable)
     {
@@ -288,14 +288,14 @@ ns_ascii_average_width (NSFont *sfont)
     w = [sfont advancementForGlyph: glyph].width;
 #endif
 
-  if (w < 0.0)
+  if (w < (CGFloat) 0.0)
     {
       NSDictionary *attrsDictionary =
         [NSDictionary dictionaryWithObject: sfont forKey: NSFontAttributeName];
       w = [ascii_printable sizeWithAttributes: attrsDictionary].width;
     }
 
-  return lrint (w / 95.0);
+  return lrint (w / (CGFloat) 95.0);
 }
 
 
@@ -323,7 +323,7 @@ ns_charset_covers(NSCharacterSet *set1, NSCharacterSet *set2, float pct)
                 off++;
           }
 //fprintf(stderr, "off = %d\ttot = %d\n", off,tot);
-    return (float)off / tot < 1.0 - pct;
+    return (float)off / tot < 1.0F - pct;
 }
 
 
@@ -514,8 +514,8 @@ static NSSet
                     if (ns_charset_covers(fset, charset, pct))
                         [families addObject: family];
                   }
-                pct -= 0.2;
-                if ([families count] > 0 || pct < 0.05)
+                pct -= 0.2F;
+                if ([families count] > 0 || pct < 0.05F)
                     break;
               }
             [charset release];
@@ -763,9 +763,9 @@ nsfont_open (FRAME_PTR f, Lisp_Object font_entity, int pixel_size)
     family = [[NSFont userFixedPitchFontOfSize: 0] familyName];
   /* Should be > 0.23 as some font descriptors (e.g. Terminus) set to that
      when setting family in ns_spec_to_descriptor(). */
-  if (ns_attribute_fvalue (fontDesc, NSFontWeightTrait) > 0.50)
+  if (ns_attribute_fvalue (fontDesc, NSFontWeightTrait) > 0.50F)
       traits |= NSBoldFontMask;
-  if (fabs (ns_attribute_fvalue (fontDesc, NSFontSlantTrait) > 0.05))
+  if (fabs (ns_attribute_fvalue (fontDesc, NSFontSlantTrait) > 0.05F))
       traits |= NSItalicFontMask;
 
   /* see http://cocoadev.com/forums/comments.php?DiscussionID=74 */
@@ -880,7 +880,7 @@ nsfont_open (FRAME_PTR f, Lisp_Object font_entity, int pixel_size)
     font_info->max_bounds.width = lrint (font_info->width);
     font_info->max_bounds.lbearing = lrint (brect.origin.x);
     font_info->max_bounds.rbearing =
-      lrint (brect.size.width - font_info->width);
+      lrint (brect.size.width - (CGFloat) font_info->width);
 
 #ifdef NS_IMPL_COCOA
     /* set up synthItal and the CG font */
@@ -1041,8 +1041,8 @@ nsfont_draw (struct glyph_string *s, int from, int to, int x, int y,
 /* NOTE: focus and clip must be set
      also, currently assumed (true in nsterm.m call) from ==0, to ==nchars */
 {
-  static char cbuf[1024];
-  char *c = cbuf;
+  static unsigned char cbuf[1024];
+  unsigned char *c = cbuf;
 #ifdef NS_IMPL_GNUSTEP
   static float advances[1024];
   float *adv = advances;
@@ -1209,7 +1209,7 @@ nsfont_draw (struct glyph_string *s, int from, int to, int x, int y,
         [bgCol set];
         DPSmoveto (context, r.origin.x, r.origin.y);
 /*[context GSSetTextDrawingMode: GSTextFillStroke]; /// not implemented yet */
-        DPSxshow (context, cbuf, advances, len);
+        DPSxshow (context, (const char *) cbuf, advances, len);
         DPSstroke (context);
         [col set];
 /*[context GSSetTextDrawingMode: GSTextFill]; /// not implemented yet */
@@ -1219,7 +1219,7 @@ nsfont_draw (struct glyph_string *s, int from, int to, int x, int y,
 
     /* draw with DPSxshow () */
     DPSmoveto (context, r.origin.x, r.origin.y);
-    DPSxshow (context, cbuf, advances, len);
+    DPSxshow (context, (const char *) cbuf, advances, len);
     DPSstroke (context);
 
     DPSgrestore (context);
@@ -1407,7 +1407,7 @@ ns_glyph_metrics (struct nsfont_info *font_info, unsigned char block)
   metrics = font_info->metrics[block];
   for (g = block<<8, i =0; i<0x100 && g < numGlyphs; g++, i++, metrics++)
     {
-      float w, lb, rb;
+      CGFloat w, lb, rb;
       NSRect r = [sfont boundingRectForGlyph: g];
 
       w = max ([sfont advancementForGlyph: g].width, 2.0);
@@ -1419,7 +1419,7 @@ ns_glyph_metrics (struct nsfont_info *font_info, unsigned char block)
       if (lb < 0)
         metrics->lbearing = round (lb - LCD_SMOOTHING_MARGIN);
       if (font_info->ital)
-        rb += 0.22 * font_info->height;
+        rb += (CGFloat) (0.22F * font_info->height);
       metrics->rbearing = lrint (w + rb + LCD_SMOOTHING_MARGIN);
 
       metrics->descent = r.origin.y < 0 ? -r.origin.y : 0;
diff --git a/src/nsimage.m b/src/nsimage.m
index 9d21ba8afca..a1703272ad2 100644
--- a/src/nsimage.m
+++ b/src/nsimage.m
@@ -334,7 +334,7 @@ static EmacsImage *ImageList = nil;
 {
   NSSize s = [self size];
   unsigned char *planes[5];
-  CGFloat r, g, b, a;
+  EmacsCGFloat r, g, b, a;
   NSColor *rgbColor;
 
   if (bmRep == nil || color == nil)
@@ -437,7 +437,7 @@ static EmacsImage *ImageList = nil;
   else
     {
       NSColor *color = [bmRep colorAtX: x y: y];
-      CGFloat r, g, b, a;
+      EmacsCGFloat r, g, b, a;
       [color getRed: &r green: &g blue: &b alpha: &a];
       return ((int)(a * 255.0) << 24)
         | ((int)(r * 255.0) << 16) | ((int)(g * 255.0) << 8)
diff --git a/src/nsmenu.m b/src/nsmenu.m
index baa683941f8..1d3d111e9a1 100644
--- a/src/nsmenu.m
+++ b/src/nsmenu.m
@@ -45,8 +45,6 @@ Carbon version by Yamamoto Mitsuharu. */
 #include <sys/types.h>
 #endif
 
-#define MenuStagger 10.0
-
 #if 0
 int menu_trace_num = 0;
 #define NSTRACE(x)        fprintf (stderr, "%s:%d: [%d] " #x "\n",        \
@@ -112,7 +110,7 @@ popup_activated (void)
     2) deep_p, submenu = nil: Recompute all submenus.
     3) deep_p, submenu = non-nil: Update contents of a single submenu.
    -------------------------------------------------------------------------- */
-void
+static void
 ns_update_menubar (struct frame *f, bool deep_p, EmacsMenu *submenu)
 {
   NSAutoreleasePool *pool;
@@ -505,6 +503,7 @@ set_frame_menubar (struct frame *f, bool first_time, bool deep_p)
 void
 x_activate_menubar (struct frame *f)
 {
+#ifdef NS_IMPL_COCOA
   NSArray *a = [[NSApp mainMenu] itemArray];
   /* Update each submenu separately so ns_update_menubar doesn't reset
      the delegate.  */
@@ -521,6 +520,7 @@ x_activate_menubar (struct frame *f)
       ++i;
     }
   ns_check_pending_open_menu ();
+#endif
 }
 
 
@@ -740,7 +740,7 @@ extern NSString *NSMenuDidBeginTrackingNotification;
           [self setSubmenu: submenu forItem: item];
           [submenu fillWithWidgetValue: wv->contents];
           [submenu release];
-          [item setAction: nil];
+          [item setAction: (SEL)nil];
         }
     }
 
@@ -757,7 +757,7 @@ extern NSString *NSMenuDidBeginTrackingNotification;
 {
   NSString *titleStr = [NSString stringWithUTF8String: title];
   NSMenuItem *item = [self addItemWithTitle: titleStr
-                                     action: nil /*@selector (menuDown:) */
+                                     action: (SEL)nil /*@selector (menuDown:) */
                               keyEquivalent: @""];
   EmacsMenu *submenu = [[EmacsMenu alloc] initWithTitle: titleStr frame: f];
   [self setSubmenu: submenu forItem: item];
@@ -1045,13 +1045,18 @@ update_frame_tool_bar (FRAME_PTR f)
     Update toolbar contents
    -------------------------------------------------------------------------- */
 {
-  int i;
+  int i, k = 0;
   EmacsView *view = FRAME_NS_VIEW (f);
   NSWindow *window = [view window];
   EmacsToolbar *toolbar = [view toolbar];
 
   block_input ();
+
+#ifdef NS_IMPL_COCOA
   [toolbar clearActive];
+#else
+  [toolbar clearAll];
+#endif
 
   /* update EmacsToolbar as in GtkUtils, build items list */
   for (i = 0; i < f->n_tool_bar_items; ++i)
@@ -1067,6 +1072,15 @@ update_frame_tool_bar (FRAME_PTR f)
       Lisp_Object helpObj;
       const char *helpText;
 
+      /* Check if this is a separator.  */
+      if (EQ (TOOLPROP (TOOL_BAR_ITEM_TYPE), Qt))
+        {
+          /* Skip separators.  Newer OSX don't show them, and on GNUStep they
+             are wide as a button, thus overflowing the toolbar most of
+             the time.  */
+          continue;
+        }
+
       /* If image is a vector, choose the image according to the
          button state.  */
       image = TOOLPROP (TOOL_BAR_ITEM_IMAGES);
@@ -1103,7 +1117,10 @@ update_frame_tool_bar (FRAME_PTR f)
           continue;
         }
 
-      [toolbar addDisplayItemWithImage: img->pixmap idx: i helpText: helpText
+      [toolbar addDisplayItemWithImage: img->pixmap
+                                   idx: k++
+                                   tag: i
+                              helpText: helpText
                                enabled: enabled_p];
 #undef TOOLPROP
     }
@@ -1111,6 +1128,7 @@ update_frame_tool_bar (FRAME_PTR f)
   if (![toolbar isVisible])
       [toolbar setVisible: YES];
 
+#ifdef NS_IMPL_COCOA
   if ([toolbar changed])
     {
       /* inform app that toolbar has changed */
@@ -1132,6 +1150,7 @@ update_frame_tool_bar (FRAME_PTR f)
       [toolbar setConfigurationFromDictionary: newDict];
       [newDict release];
     }
+#endif
 
   FRAME_TOOLBAR_HEIGHT (f) =
     NSHeight ([window frameRectForContentRect: NSMakeRect (0, 0, 0, 0)])
@@ -1159,6 +1178,7 @@ update_frame_tool_bar (FRAME_PTR f)
   [self setDelegate: self];
   identifierToItem = [[NSMutableDictionary alloc] initWithCapacity: 10];
   activeIdentifiers = [[NSMutableArray alloc] initWithCapacity: 8];
+  prevIdentifiers = nil;
   prevEnablement = enablement = 0L;
   return self;
 }
@@ -1180,18 +1200,29 @@ update_frame_tool_bar (FRAME_PTR f)
   enablement = 0L;
 }
 
+- (void) clearAll
+{
+  [self clearActive];
+  while ([[self items] count] > 0)
+    [self removeItemAtIndex: 0];
+}
+
 - (BOOL) changed
 {
   return [activeIdentifiers isEqualToArray: prevIdentifiers] &&
     enablement == prevEnablement ? NO : YES;
 }
 
-- (void) addDisplayItemWithImage: (EmacsImage *)img idx: (int)idx
-                        helpText: (const char *)help enabled: (BOOL)enabled
+- (void) addDisplayItemWithImage: (EmacsImage *)img
+                             idx: (int)idx
+                             tag: (int)tag
+                        helpText: (const char *)help
+                         enabled: (BOOL)enabled
 {
   /* 1) come up w/identifier */
   NSString *identifier
       = [NSString stringWithFormat: @"%u", [img hash]];
+  [activeIdentifiers addObject: identifier];
 
   /* 2) create / reuse item */
   NSToolbarItem *item = [identifierToItem objectForKey: identifier];
@@ -1203,20 +1234,25 @@ update_frame_tool_bar (FRAME_PTR f)
       [item setToolTip: [NSString stringWithUTF8String: help]];
       [item setTarget: emacsView];
       [item setAction: @selector (toolbarClicked:)];
+      [identifierToItem setObject: item forKey: identifier];
     }
 
-  [item setTag: idx];
+#ifdef NS_IMPL_GNUSTEP
+  [self insertItemWithItemIdentifier: identifier atIndex: idx];
+#endif
+  
+  [item setTag: tag];
   [item setEnabled: enabled];
 
   /* 3) update state */
-  [identifierToItem setObject: item forKey: identifier];
-  [activeIdentifiers addObject: identifier];
   enablement = (enablement << 1) | (enabled == YES);
 }
 
 /* This overrides super's implementation, which automatically sets
    all items to enabled state (for some reason). */
-- (void)validateVisibleItems { }
+- (void)validateVisibleItems
+{
+}
 
 
 /* delegate methods */
@@ -1239,7 +1275,8 @@ update_frame_tool_bar (FRAME_PTR f)
 - (NSArray *)toolbarAllowedItemIdentifiers: (NSToolbar *)toolbar
 {
   /* return entire set... */
-  return [identifierToItem allKeys];
+  return activeIdentifiers;
+  //return [identifierToItem allKeys];
 }
 
 /* optional and unneeded */
@@ -1531,7 +1568,7 @@ ns_popup_dialog (Lisp_Object position, Lisp_Object contents, Lisp_Object header)
   [img autorelease];
   [imgView autorelease];
 
-  aStyle = NSTitledWindowMask;
+  aStyle = NSTitledWindowMask|NSClosableWindowMask|NSUtilityWindowMask;
   flag = YES;
   rows = 0;
   cols = 1;
@@ -1599,9 +1636,6 @@ ns_popup_dialog (Lisp_Object position, Lisp_Object contents, Lisp_Object header)
   [self setOneShot: YES];
   [self setReleasedWhenClosed: YES];
   [self setHidesOnDeactivate: YES];
-  [self setStyleMask:
-          NSTitledWindowMask|NSClosableWindowMask|NSUtilityWindowMask];
-
   return self;
 }
 
diff --git a/src/nsselect.m b/src/nsselect.m
index bb9eacd23cd..6053ee9ceb2 100644
--- a/src/nsselect.m
+++ b/src/nsselect.m
@@ -182,7 +182,7 @@ ns_get_local_selection (Lisp_Object selection_name,
                        Lisp_Object target_type)
 {
   Lisp_Object local_value;
-  Lisp_Object handler_fn, value, type, check;
+  Lisp_Object handler_fn, value, check;
   ptrdiff_t count;
 
   local_value = assq_no_quit (selection_name, Vselection_alist);
@@ -203,7 +203,6 @@ ns_get_local_selection (Lisp_Object selection_name,
   check = value;
   if (CONSP (value) && SYMBOLP (XCAR (value)))
     {
-      type = XCAR (value);
       check = XCDR (value);
     }
 
diff --git a/src/nsterm.h b/src/nsterm.h
index 07cfc2e022e..fd8c9baa3e4 100644
--- a/src/nsterm.h
+++ b/src/nsterm.h
@@ -51,6 +51,16 @@ along with GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.  */
 
 #ifdef __OBJC__
 
+/* CGFloat on GNUStep may be 4 or 8 byte, but functions expect float* for some
+   versions.
+   On Cocoa, functions expect CGFloat*. Make compatible type.  */
+#if defined (NS_IMPL_COCOA) || GNUSTEP_GUI_MAJOR_VERSION > 0 || \
+    GNUSTEP_GUI_MINOR_VERSION >= 22
+typedef CGFloat EmacsCGFloat;
+#else
+typedef float EmacsCGFloat;
+#endif
+
 /* ==========================================================================
 
    The Emacs application
@@ -60,6 +70,10 @@ along with GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.  */
 /* We override sendEvent: as a means to stop/start the event loop */
 @interface EmacsApp : NSApplication
 {
+#ifdef NS_IMPL_GNUSTEP
+@public
+  int nextappdefined;
+#endif
 }
 - (void)logNotification: (NSNotification *)notification;
 - (void)sendEvent: (NSEvent *)theEvent;
@@ -68,8 +82,18 @@ along with GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.  */
 - (void)fd_handler: (id)unused;
 - (void)timeout_handler: (NSTimer *)timedEntry;
 - (BOOL)fulfillService: (NSString *)name withArg: (NSString *)arg;
+#ifdef NS_IMPL_GNUSTEP
+- (void)sendFromMainThread:(id)unused;
+#endif
 @end
 
+#ifdef NS_IMPL_GNUSTEP
+/* Dummy class to get rid of startup warnings.  */
+@interface EmacsDocument : NSDocument
+{
+}
+@end
+#endif
 
 /* ==========================================================================
 
@@ -128,8 +152,7 @@ along with GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.  */
 #endif
 
 #ifdef NS_IMPL_GNUSTEP
-/* Not declared, but useful. */
-- (void) unlockFocusNeedsFlush: (BOOL)needs;
+- (void)windowDidMove: (id)sender;
 #endif
 @end
 
@@ -199,10 +222,14 @@ along with GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.  */
    }
 - initForView: (EmacsView *)view withIdentifier: (NSString *)identifier;
 - (void) clearActive;
+- (void) clearAll;
 - (BOOL) changed;
-- (void) addDisplayItemWithImage: (EmacsImage *)img idx: (int)idx
+- (void) addDisplayItemWithImage: (EmacsImage *)img
+                             idx: (int)idx
+                             tag: (int)tag
                         helpText: (const char *)help
                          enabled: (BOOL)enabled;
+
 /* delegate methods */
 - (NSToolbarItem *)toolbar: (NSToolbar *)toolbar
      itemForItemIdentifier: (NSString *)itemIdentifier
@@ -267,14 +294,10 @@ along with GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.  */
 @interface EmacsSavePanel : NSSavePanel
 {
 }
-- (NSString *) getFilename;
-- (NSString *) getDirectory;
 @end
 @interface EmacsOpenPanel : NSOpenPanel
 {
 }
-- (NSString *) getFilename;
-- (NSString *) getDirectory;
 @end
 
 @interface EmacsFileDelegate : NSObject
@@ -335,7 +358,7 @@ along with GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.  */
    NSResponder *prevResponder;
 
    /* offset to the bottom of knob of last mouse down */
-   float last_mouse_offset;
+   CGFloat last_mouse_offset;
    float min_portion;
    int pixel_height;
    int last_hit_part;
@@ -789,9 +812,9 @@ extern int ns_lisp_to_color (Lisp_Object color, NSColor **col);
 extern NSColor *ns_lookup_indexed_color (unsigned long idx, struct frame *f);
 extern unsigned long ns_index_color (NSColor *color, struct frame *f);
 extern void ns_free_indexed_color (unsigned long idx, struct frame *f);
-extern const char *ns_get_pending_menu_title ();
+extern const char *ns_get_pending_menu_title (void);
 extern void ns_check_menu_open (NSMenu *menu);
-extern void ns_check_pending_open_menu ();
+extern void ns_check_pending_open_menu (void);
 #endif
 
 /* C access to ObjC functionality */
@@ -840,6 +863,7 @@ extern int x_display_pixel_height (struct ns_display_info *);
 extern int x_display_pixel_width (struct ns_display_info *);
 
 /* This in nsterm.m */
+extern void x_destroy_window (struct frame *f);
 extern int ns_select (int nfds, fd_set *readfds, fd_set *writefds,
                       fd_set *exceptfds, EMACS_TIME *timeout,
                       sigset_t *sigmask);
diff --git a/src/nsterm.m b/src/nsterm.m
index e882f00e977..93f693fe55e 100644
--- a/src/nsterm.m
+++ b/src/nsterm.m
@@ -60,6 +60,10 @@ GNUstep port and post-20 update by Adrian Robert (arobert@cogsci.ucsd.edu)
 #include "buffer.h"
 #include "font.h"
 
+#ifdef NS_IMPL_GNUSTEP
+#include "process.h"
+#endif
+
 /* call tracing */
 #if 0
 int term_trace_num = 0;
@@ -196,7 +200,9 @@ static BOOL gsaved = NO;
 static BOOL ns_fake_keydown = NO;
 int ns_tmp_flags; /* FIXME */
 struct nsfont_info *ns_tmp_font; /* FIXME */
+#ifdef NS_IMPL_COCOA
 static BOOL ns_menu_bar_is_hidden = NO;
+#endif
 /*static int debug_lock = 0; */
 
 /* event loop */
@@ -228,6 +234,7 @@ static struct {
   NULL, 0, 0
 };
 
+#ifdef NS_IMPL_COCOA
 /*
  * State for pending menu activation:
  * MENU_NONE     Normal state
@@ -246,6 +253,7 @@ static CGPoint menu_mouse_point;
 
 /* Title for the menu to open.  */
 static char *menu_pending_title = 0;
+#endif
 
 /* Convert modifiers in a NeXTstep event to emacs style modifiers.  */
 #define NS_FUNCTION_KEY_MASK 0x800000
@@ -317,8 +325,6 @@ static char *menu_pending_title = 0;
       ns_send_appdefined (-1);                                          \
     }
 
-void x_set_cursor_type (struct frame *, Lisp_Object, Lisp_Object);
-
 /* TODO: get rid of need for these forward declarations */
 static void ns_condemn_scroll_bars (struct frame *f);
 static void ns_judge_scroll_bars (struct frame *f);
@@ -670,8 +676,6 @@ ns_update_begin (struct frame *f)
    -------------------------------------------------------------------------- */
 {
   NSView *view = FRAME_NS_VIEW (f);
-  NSRect r = [view frame];
-  NSBezierPath *bp;
   NSTRACE (ns_update_begin);
 
   ns_update_auto_hide_menu_bar ();
@@ -683,9 +687,15 @@ ns_update_begin (struct frame *f)
      is for the minibuffer.  But the display engine may draw more because
      we have set the frame as garbaged.  So reset clip path to the whole
      view.  */
+#ifdef NS_IMPL_COCOA
+  {
+    NSBezierPath *bp;
+    NSRect r = [view frame];
   bp = [[NSBezierPath bezierPathWithRect: r] retain];
   [bp setClip];
   [bp release];
+  }
+#endif
 
 #ifdef NS_IMPL_GNUSTEP
   uRect = NSMakeRect (0, 0, 0, 0);
@@ -772,20 +782,13 @@ ns_update_end (struct frame *f)
    external (RIF) call; for whole frame, called after update_window_end
    -------------------------------------------------------------------------- */
 {
-  NSView *view = FRAME_NS_VIEW (f);
+  EmacsView *view = FRAME_NS_VIEW (f);
 
 /*   if (f == MOUSE_HL_INFO (f)->mouse_face_mouse_frame) */
     MOUSE_HL_INFO (f)->mouse_face_defer = 0;
 
     block_input ();
 
-#ifdef NS_IMPL_GNUSTEP
-  /* trigger flush only in the rectangle we tracked as being drawn */
-  [view unlockFocusNeedsFlush: NO];
-/*fprintf (stderr, " (%.0f, %.0f : %.0f x %.0f)", uRect.origin.x, uRect.origin.y, uRect.size.width, uRect.size.height); */
-  [view lockFocusInRect: uRect];
-#endif
-
   [view unlockFocus];
   [[view window] flushWindow];
 
@@ -818,13 +821,6 @@ ns_focus (struct frame *f, NSRect *r, int n)
    -------------------------------------------------------------------------- */
 {
 //  NSTRACE (ns_focus);
-#ifdef NS_IMPL_GNUSTEP
-  NSRect u;
-    if (n == 2)
-      u = NSUnionRect (r[0], r[1]);
-    else if (r)
-      u = *r;
-#endif
 /* static int c =0;
    fprintf (stderr, "focus: %d", c++);
    if (r) fprintf (stderr, " (%.0f, %.0f : %.0f x %.0f)", r->origin.x, r->origin.y, r->size.width, r->size.height);
@@ -843,33 +839,11 @@ ns_focus (struct frame *f, NSRect *r, int n)
             }
 
           if (view)
-#ifdef NS_IMPL_GNUSTEP
-            r ? [view lockFocusInRect: u] : [view lockFocus];
-#else
             [view lockFocus];
-#endif
           focus_view = view;
 /*if (view) debug_lock++; */
         }
-#ifdef NS_IMPL_GNUSTEP
-      else
-        {
-          /* more than one rect being drawn into */
-          if (view && r)
-            {
-              [view unlockFocus]; /* add prev rect to redraw list */
-              [view lockFocusInRect: u]; /* focus for draw in new rect */
-            }
-        }
-#endif
     }
-#ifdef NS_IMPL_GNUSTEP
-  else
-    {
-      /* in batch mode, but in GNUstep must still track rectangles explicitly */
-      uRect = (r ? NSUnionRect (uRect, u) : [FRAME_NS_VIEW (f) visibleRect]);
-    }
-#endif
 
   /* clipping */
   if (r)
@@ -1317,12 +1291,17 @@ x_set_window_size (struct frame *f, int change_grav, int cols, int rows)
 
   /* If we have a toolbar, take its height into account. */
   if (tb && ! [view isFullscreen])
+    {
     /* NOTE: previously this would generate wrong result if toolbar not
              yet displayed and fixing toolbar_height=32 helped, but
              now (200903) seems no longer needed */
     FRAME_TOOLBAR_HEIGHT (f) =
       NSHeight ([window frameRectForContentRect: NSMakeRect (0, 0, 0, 0)])
         - FRAME_NS_TITLEBAR_HEIGHT (f);
+#ifdef NS_IMPL_GNUSTEP
+      FRAME_TOOLBAR_HEIGHT (f) -= 3;
+#endif
+    }
   else
     FRAME_TOOLBAR_HEIGHT (f) = 0;
 
@@ -1548,7 +1527,7 @@ ns_get_color (const char *name, NSColor **col)
         }
     }
 
-  if (r >= 0.0)
+  if (r >= 0.0F)
     {
       *col = [NSColor colorWithCalibratedRed: r green: g blue: b alpha: 1.0];
       unblock_input ();
@@ -1609,7 +1588,7 @@ ns_color_to_lisp (NSColor *col)
      Convert a color to a lisp string with the RGB equivalent
    -------------------------------------------------------------------------- */
 {
-  CGFloat red, green, blue, alpha, gray;
+  EmacsCGFloat red, green, blue, alpha, gray;
   char buf[1024];
   const char *str;
   NSTRACE (ns_color_to_lisp);
@@ -1651,7 +1630,7 @@ ns_query_color(void *col, XColor *color_def, int setPixel)
          and set color_def pixel to the resulting index.
    -------------------------------------------------------------------------- */
 {
-  CGFloat r, g, b, a;
+  EmacsCGFloat r, g, b, a;
 
   [((NSColor *)col) getRed: &r green: &g blue: &b alpha: &a];
   color_def->red   = r * 65535;
@@ -1696,26 +1675,6 @@ ns_defined_color (struct frame *f,
 }
 
 
-unsigned long
-ns_get_rgb_color (struct frame *f, float r, float g, float b, float a)
-/* --------------------------------------------------------------------------
-    return an autoreleased RGB color
-   -------------------------------------------------------------------------- */
-{
-/*static int c = 1; fprintf (stderr, "color request %d\n", c++); */
-  if (r < 0.0) r = 0.0;
-  else if (r > 1.0) r = 1.0;
-  if (g < 0.0) g = 0.0;
-  else if (g > 1.0) g = 1.0;
-  if (b < 0.0) b = 0.0;
-  else if (b > 1.0) b = 1.0;
-  if (a < 0.0) a = 0.0;
-  else if (a > 1.0) a = 1.0;
-  return (unsigned long) ns_index_color(
-    [NSColor colorWithCalibratedRed: r green: g blue: b alpha: a], f);
-}
-
-
 void
 x_set_frame_alpha (struct frame *f)
 /* --------------------------------------------------------------------------
@@ -1723,7 +1682,6 @@ x_set_frame_alpha (struct frame *f)
    -------------------------------------------------------------------------- */
 {
   struct ns_display_info *dpyinfo = FRAME_NS_DISPLAY_INFO (f);
-  EmacsView *view = FRAME_NS_VIEW (f);
   double alpha = 1.0;
   double alpha_min = 1.0;
 
@@ -1745,7 +1703,10 @@ x_set_frame_alpha (struct frame *f)
     alpha = alpha_min;
 
 #ifdef NS_IMPL_COCOA
+  {
+    EmacsView *view = FRAME_NS_VIEW (f);
   [[view window] setAlphaValue: alpha];
+  }
 #endif
 }
 
@@ -1798,7 +1759,7 @@ x_set_mouse_position (struct frame *f, int h, int v)
 
 
 static int
-note_mouse_movement (struct frame *frame, float x, float y)
+note_mouse_movement (struct frame *frame, CGFloat x, CGFloat y)
 /*   ------------------------------------------------------------------------
      Called by EmacsView on mouseMovement events.  Passes on
      to emacs mainstream code if we moved off of a rect of interest
@@ -2257,7 +2218,6 @@ ns_draw_fringe_bitmap (struct window *w, struct glyph_row *row,
 {
   struct frame *f = XFRAME (WINDOW_FRAME (w));
   struct face *face = p->face;
-  int rowY;
   static EmacsImage **bimgs = NULL;
   static int nBimgs = 0;
 
@@ -2271,7 +2231,6 @@ ns_draw_fringe_bitmap (struct window *w, struct glyph_row *row,
     }
 
   /* Must clip because of partially visible lines.  */
-  rowY = WINDOW_TO_FRAME_PIXEL_Y (w, row->y);
   ns_clip_to_row (w, row, -1, YES);
 
   if (!p->overlay_p)
@@ -2359,7 +2318,7 @@ ns_draw_fringe_bitmap (struct window *w, struct glyph_row *row,
       [ns_lookup_indexed_color(face->background, f) set];
       NSRectFill (r);
       [img setXBMColor: ns_lookup_indexed_color(face->foreground, f)];
-#if !defined (NS_IMPL_COCOA) || MAC_OS_X_VERSION_MAX_ALLOWED >= MAC_OS_X_VERSION_10_6
+#if defined (NS_IMPL_COCOA) && MAC_OS_X_VERSION_MAX_ALLOWED >= MAC_OS_X_VERSION_10_6
       [img drawInRect: r
               fromRect: NSZeroRect
              operation: NSCompositeSourceOver
@@ -2391,7 +2350,6 @@ ns_draw_window_cursor (struct window *w, struct glyph_row *glyph_row,
   int fx, fy, h, cursor_height;
   struct frame *f = WINDOW_XFRAME (w);
   struct glyph *phys_cursor_glyph;
-  int overspill;
   struct glyph *cursor_glyph;
   struct face *face;
   NSColor *hollow_color = FRAME_BACKGROUND_COLOR (f);
@@ -2598,7 +2556,7 @@ ns_get_glyph_string_clip_rect (struct glyph_string *s, NativeRectangle *nr)
   --------------------------------------------------------------------- */
 
 static void
-ns_draw_underwave (struct glyph_string *s, CGFloat width, CGFloat x)
+ns_draw_underwave (struct glyph_string *s, EmacsCGFloat width, EmacsCGFloat x)
 {
   int wave_height = 3, wave_length = 2;
   int y, dx, dy, odd, xmax;
@@ -2616,7 +2574,7 @@ ns_draw_underwave (struct glyph_string *s, CGFloat width, CGFloat x)
   NSRectClip (waveClip);
 
   /* Draw the waves */
-  a.x = x - ((int)(x) % dx) + 0.5;
+  a.x = x - ((int)(x) % dx) + (EmacsCGFloat) 0.5;
   b.x = a.x + dx;
   odd = (int)(a.x/dx) % 2;
   a.y = b.y = y + 0.5;
@@ -2756,7 +2714,8 @@ ns_draw_text_decoration (struct glyph_string *s, struct face *face,
 }
 
 static void
-ns_draw_box (NSRect r, float thickness, NSColor *col, char left_p, char right_p)
+ns_draw_box (NSRect r, CGFloat thickness, NSColor *col,
+             char left_p, char right_p)
 /* --------------------------------------------------------------------------
     Draw an unfilled rect inside r, optionally leaving left and/or right open.
     Note we can't just use an NSDrawRect command, because of the possibility
@@ -3033,7 +2992,7 @@ ns_dumpglyphs_image (struct glyph_string *s, NSRect r)
   /* Draw the image.. do we need to draw placeholder if img ==nil? */
   if (img != nil)
     {
-#if !defined (NS_IMPL_COCOA) || MAC_OS_X_VERSION_MAX_ALLOWED >= MAC_OS_X_VERSION_10_6
+#if defined (NS_IMPL_COCOA) && MAC_OS_X_VERSION_MAX_ALLOWED >= MAC_OS_X_VERSION_10_6
       NSRect dr = NSMakeRect (x, y, s->slice.width, s->slice.height);
       NSRect ir = NSMakeRect (s->slice.x, s->slice.y,
                               s->slice.width, s->slice.height);
@@ -3358,6 +3317,19 @@ ns_send_appdefined (int value)
 {
   /*NSTRACE (ns_send_appdefined); */
 
+#ifdef NS_IMPL_GNUSTEP
+  // GNUStep needs postEvent to happen on the main thread.
+  if (! [[NSThread currentThread] isMainThread])
+    {
+      EmacsApp *app = (EmacsApp *)NSApp;
+      app->nextappdefined = value;
+      [app performSelectorOnMainThread:@selector (sendFromMainThread:)
+                            withObject:nil
+                         waitUntilDone:YES];
+      return;
+    }
+#endif
+
   /* Only post this event if we haven't already posted one.  This will end
        the [NXApp run] main loop after having processed all events queued at
        this moment.  */
@@ -3417,6 +3389,9 @@ check_native_fs ()
 }
 #endif
 
+/* GNUStep and OSX <= 10.4 does not have cancelTracking.  */
+#if defined (NS_IMPL_COCOA) && \
+  MAC_OS_X_VERSION_MAX_ALLOWED >= MAC_OS_X_VERSION_10_5
 const char *
 ns_get_pending_menu_title ()
 {
@@ -3427,10 +3402,6 @@ ns_get_pending_menu_title ()
 void
 ns_check_menu_open (NSMenu *menu)
 {
-  /* GNUStep and OSX <= 10.4 does not have cancelTracking.  */
-#if defined(NS_IMPL_COCOA) && \
-  MAC_OS_X_VERSION_MAX_ALLOWED >= MAC_OS_X_VERSION_10_5
-
   /* Click in menu bar? */
   NSArray *a = [[NSApp mainMenu] itemArray];
   int i;
@@ -3460,14 +3431,12 @@ ns_check_menu_open (NSMenu *menu)
           menu_will_open_state = MENU_NONE;
         }
     }
-#endif
 }
 
 /* Redo saved menu click if state is MENU_PENDING.  */
 void
 ns_check_pending_open_menu ()
 {
-#ifdef NS_IMPL_COCOA
   if (menu_will_open_state == MENU_PENDING)
     {
       CGEventSourceRef source
@@ -3484,9 +3453,8 @@ ns_check_pending_open_menu ()
 
       menu_will_open_state = MENU_OPENING;
     }
-#endif
 }
-
+#endif /* NS_IMPL_COCOA) && >= MAC_OS_X_VERSION_10_5 */
 
 static int
 ns_read_socket (struct terminal *terminal, struct input_event *hold_quit)
@@ -4392,6 +4360,12 @@ ns_term_init (Lisp_Object display_name)
 
   [NSApp run];
   ns_do_open_file = YES;
+
+#ifdef NS_IMPL_GNUSTEP
+  /* GNUstep steals SIGCHLD for use in NSTask, but we don't use NSTask.
+     We must re-catch it so subprocess works.  */
+  catch_child_signal ();
+#endif
   return dpyinfo;
 }
 
@@ -4699,6 +4673,13 @@ not_in_argv (NSString *arg)
   ns_send_appdefined (-2);
 }
 
+#ifdef NS_IMPL_GNUSTEP
+- (void)sendFromMainThread:(id)unused
+{
+  ns_send_appdefined (nextappdefined);
+}
+#endif
+
 - (void)fd_handler:(id)unused
 /* --------------------------------------------------------------------------
      Check data waiting on file descriptors and terminate if so
@@ -4863,7 +4844,7 @@ not_in_argv (NSString *arg)
   NSEvent *e =[[self window] currentEvent];
   struct face *face =FRAME_DEFAULT_FACE (emacsframe);
   id newFont;
-  float size;
+  CGFloat size;
 
   NSTRACE (changeFont);
   if (!emacs_event)
@@ -4982,7 +4963,16 @@ not_in_argv (NSString *arg)
         {
           /* COUNTERHACK: map 'Delete' on upper-right main KB to 'Backspace',
              because Emacs treats Delete and KP-Delete same (in simple.el). */
-          if (fnKeysym == 0xFFFF && [theEvent keyCode] == 0x33)
+          if ((fnKeysym == 0xFFFF && [theEvent keyCode] == 0x33)
+#ifdef NS_IMPL_GNUSTEP
+              /*  GNUstep uses incompatible keycodes, even for those that are
+                  supposed to be hardware independent.  Just check for delete.
+                  Keypad delete does not have keysym 0xFFFF.
+                  See http://savannah.gnu.org/bugs/?25395
+              */
+              || (fnKeysym == 0xFFFF && code == 127)
+#endif
+            )
             code = 0xFF08; /* backspace */
           else
             code = fnKeysym;
@@ -5135,10 +5125,14 @@ not_in_argv (NSString *arg)
 
 #if !defined (NS_IMPL_COCOA) || MAC_OS_X_VERSION_MAX_ALLOWED < MAC_OS_X_VERSION_10_6
   /* if we get here we should send the key for input manager processing */
+  /* Disable warning, there is nothing a user can do about it anyway, and
+     it does not seem to matter.  */
+#if 0
   if (firstTime && [[NSInputManager currentInputManager]
                      wantsToDelayTextChangeNotifications] == NO)
     fprintf (stderr,
           "Emacs: WARNING: TextInput mgr wants marked text to be permanent!\n");
+#endif
   firstTime = NO;
 #endif
   if (NS_KEYLOG && !processingCompose)
@@ -5346,7 +5340,12 @@ not_in_argv (NSString *arg)
   return NSMakeRange (NSNotFound, 0);
 }
 
+#if defined (NS_IMPL_COCOA) || GNUSTEP_GUI_MAJOR_VERSION > 0 || \
+    GNUSTEP_GUI_MINOR_VERSION > 22
 - (NSUInteger)characterIndexForPoint: (NSPoint)thePoint
+#else
+- (unsigned int)characterIndexForPoint: (NSPoint)thePoint
+#endif
 {
   if (NS_KEYLOG)
     NSLog (@"characterIndexForPoint request");
@@ -5385,7 +5384,7 @@ not_in_argv (NSString *arg)
 
   if ([theEvent type] == NSScrollWheel)
     {
-      float delta = [theEvent deltaY];
+      CGFloat delta = [theEvent deltaY];
       /* Mac notebooks send wheel events w/delta =0 when trackpad scrolling */
       if (delta == 0)
         return;
@@ -5569,7 +5568,6 @@ not_in_argv (NSString *arg)
 
   if (oldr != rows || oldc != cols || neww != oldw || newh != oldh)
     {
-      struct frame *f = emacsframe;
       NSView *view = FRAME_NS_VIEW (emacsframe);
       NSWindow *win = [view window];
       NSSize sz = [win resizeIncrements];
@@ -5602,7 +5600,7 @@ not_in_argv (NSString *arg)
 #ifdef NS_IMPL_GNUSTEP
   gsextra = 3;
 #endif
-  
+
   NSTRACE (windowWillResize);
 /*fprintf (stderr,"Window will resize: %.0f x %.0f\n",frameSize.width,frameSize.height); */
 
@@ -5668,7 +5666,7 @@ not_in_argv (NSString *arg)
 
 - (void)windowDidResize: (NSNotification *)notification
 {
-  if (! [self fsIsNative]) 
+  if (! [self fsIsNative])
     {
       NSWindow *theWindow = [notification object];
       /* We can get notification on the non-FS window when in
@@ -5778,7 +5776,6 @@ not_in_argv (NSString *arg)
   NSRect r, wr;
   Lisp_Object tem;
   NSWindow *win;
-  NSButton *toggleButton;
   NSSize sz;
   NSColor *col;
   NSString *name;
@@ -5854,9 +5851,12 @@ not_in_argv (NSString *arg)
   [win setToolbar: toolbar];
   [toolbar setVisible: NO];
 #ifdef NS_IMPL_COCOA
+  {
+    NSButton *toggleButton;
   toggleButton = [win standardWindowButton: NSWindowToolbarButton];
   [toggleButton setTarget: self];
   [toggleButton setAction: @selector (toggleToolbar: )];
+  }
 #endif
   FRAME_TOOLBAR_HEIGHT (f) = 0;
 
@@ -5880,7 +5880,7 @@ not_in_argv (NSString *arg)
   col = ns_lookup_indexed_color (NS_FACE_BACKGROUND
                                   (FRAME_DEFAULT_FACE (emacsframe)), emacsframe);
   [win setBackgroundColor: col];
-  if ([col alphaComponent] != 1.0)
+  if ([col alphaComponent] != (EmacsCGFloat) 1.0)
     [win setOpaque: NO];
 
   [self allocateGState];
@@ -5973,7 +5973,7 @@ not_in_argv (NSString *arg)
       result = ns_userRect.size.height ? ns_userRect : result;
       ns_userRect = NSMakeRect (0, 0, 0, 0);
       [self setFSValue: FULLSCREEN_NONE];
-      maximized_width = maximized_width = -1;
+      maximized_width = maximized_height = -1;
     }
 
   if (fs_before_fs == -1) next_maximized = -1;
@@ -6066,7 +6066,9 @@ not_in_argv (NSString *arg)
 {
   [self setFSValue: fs_before_fs];
   fs_before_fs = -1;
+#ifdef NS_IMPL_COCOA
   [self updateCollectionBehaviour];
+#endif
   if (FRAME_EXTERNAL_TOOL_BAR (emacsframe))
     {
       [toolbar setVisible:YES];
@@ -6113,7 +6115,7 @@ not_in_argv (NSString *arg)
     }
 }
 #endif
- 
+
 - (void)toggleFullScreen: (id)sender
 {
   NSWindow *w, *fw;
@@ -6125,7 +6127,9 @@ not_in_argv (NSString *arg)
 
   if (fs_is_native)
     {
+#ifdef NS_IMPL_COCOA
       [[self window] toggleFullScreen:sender];
+#endif
       return;
     }
 
@@ -6171,7 +6175,7 @@ not_in_argv (NSString *arg)
       [fw useOptimizedDrawing: YES];
       [fw setResizeIncrements: sz];
       [fw setBackgroundColor: col];
-      if ([col alphaComponent] != 1.0)
+      if ([col alphaComponent] != (EmacsCGFloat) 1.0)
         [fw setOpaque: NO];
 
       f->border_width = 0;
@@ -6209,7 +6213,7 @@ not_in_argv (NSString *arg)
       [w setContentView:[fw contentView]];
       [w setResizeIncrements: sz];
       [w setBackgroundColor: col];
-      if ([col alphaComponent] != 1.0)
+      if ([col alphaComponent] != (EmacsCGFloat) 1.0)
         [w setOpaque: NO];
 
       f->border_width = bwidth;
@@ -6903,10 +6907,11 @@ not_in_argv (NSString *arg)
     }
   else
     {
-      float pos, por;
+      float pos;
+      CGFloat por;
       portion = max ((float)whole*min_portion/pixel_height, portion);
       pos = (float)position / (whole - portion);
-      por = (float)portion/whole;
+      por = (CGFloat)portion/whole;
 #if defined (NS_IMPL_COCOA) && MAC_OS_X_VERSION_MAX_ALLOWED > MAC_OS_X_VERSION_10_5
       [self setKnobProportion: por];
       [self setDoubleValue: pos];
@@ -6931,7 +6936,7 @@ not_in_argv (NSString *arg)
   *part = last_hit_part;
   *window = win;
   XSETINT (*y, pixel_height);
-  if ([self floatValue] > 0.999)
+  if ([self floatValue] > 0.999F)
     XSETINT (*x, pixel_height);
   else
     XSETINT (*x, pixel_height * [self floatValue]);
@@ -7005,7 +7010,7 @@ not_in_argv (NSString *arg)
   NSRect sr, kr;
   /* hitPart is only updated AFTER event is passed on */
   NSScrollerPart part = [self testPart: [e locationInWindow]];
-  double inc = 0.0, loc, kloc, pos;
+  CGFloat inc = 0.0, loc, kloc, pos;
   int edge = 0;
 
   NSTRACE (EmacsScroller_mouseDown);
@@ -7104,7 +7109,6 @@ not_in_argv (NSString *arg)
 {
     NSRect sr;
     double loc, pos;
-    int edge = 0;
 
     NSTRACE (EmacsScroller_mouseDragged);
 
@@ -7115,15 +7119,13 @@ not_in_argv (NSString *arg)
       if (loc <= 0.0)
         {
           loc = 0.0;
-          edge = -1;
         }
       else if (loc >= NSHeight (sr) + last_mouse_offset)
         {
           loc = NSHeight (sr) + last_mouse_offset;
-          edge = 1;
         }
 
-      pos = /*(edge ? loc :*/ (loc - last_mouse_offset) / NSHeight (sr);
+      pos = (loc - last_mouse_offset) / NSHeight (sr);
       [self sendScrollEventAtLoc: pos fromEvent: e];
 }
 
@@ -7150,6 +7152,12 @@ not_in_argv (NSString *arg)
 @end  /* EmacsScroller */
 
 
+#ifdef NS_IMPL_GNUSTEP
+/* Dummy class to get rid of startup warnings.  */
+@implementation EmacsDocument
+
+@end
+#endif
 
 
 /* ==========================================================================
diff --git a/src/process.c b/src/process.c
index 45e8afdd22c..33035078df9 100644
--- a/src/process.c
+++ b/src/process.c
@@ -4528,7 +4528,7 @@ wait_reading_process_output (intmax_t time_limit, int nsecs, int read_kbd,
             }
 #endif
 
-#if defined (USE_GTK) || defined (HAVE_GCONF) || defined (HAVE_GSETTINGS)
+#if defined (HAVE_GLIB)
           nfds = xg_select
 #elif defined (HAVE_NS)
           nfds = ns_select
@@ -7029,6 +7029,17 @@ integer or floating point values.
   return system_process_attributes (pid);
 }
 
+#ifndef NS_IMPL_GNUSTEP
+static
+#endif
+void
+catch_child_signal (void)
+{
+  struct sigaction action;
+  emacs_sigaction_init (&action, deliver_child_signal);
+  sigaction (SIGCHLD, &action, 0);
+}
+
 
 /* This is not called "init_process" because that is the name of a
    Mach system call, so it would cause problems on Darwin systems.  */
@@ -7044,9 +7055,7 @@ init_process_emacs (void)
   if (! noninteractive || initialized)
 #endif
     {
-      struct sigaction action;
-      emacs_sigaction_init (&action, deliver_child_signal);
-      sigaction (SIGCHLD, &action, 0);
+      catch_child_signal ();
     }
 
   FD_ZERO (&input_wait_mask);
diff --git a/src/process.h b/src/process.h
index 765e5d82567..0c4e17e68cf 100644
--- a/src/process.h
+++ b/src/process.h
@@ -217,5 +217,8 @@ extern void add_read_fd (int fd, fd_callback func, void *data);
 extern void delete_read_fd (int fd);
 extern void add_write_fd (int fd, fd_callback func, void *data);
 extern void delete_write_fd (int fd);
+#ifdef NS_IMPL_GNUSTEP
+extern void catch_child_signal (void);
+#endif
 
 INLINE_HEADER_END
diff --git a/src/profiler.c b/src/profiler.c
index 0a0a4d0bc57..aba81344c68 100644
--- a/src/profiler.c
+++ b/src/profiler.c
@@ -138,10 +138,8 @@ static void evict_lower_half (log_t *log)
 static void
 record_backtrace (log_t *log, EMACS_INT count)
 {
-  struct backtrace *backlist = backtrace_list;
   Lisp_Object backtrace;
-  ptrdiff_t index, i = 0;
-  ptrdiff_t asize;
+  ptrdiff_t index;
 
   if (!INTEGERP (log->next_free))
     /* FIXME: transfer the evicted counts to a special entry rather
@@ -151,16 +149,7 @@ record_backtrace (log_t *log, EMACS_INT count)
 
   /* Get a "working memory" vector.  */
   backtrace = HASH_KEY (log, index);
-  asize = ASIZE (backtrace);
-
-  /* Copy the backtrace contents into working memory.  */
-  for (; i < asize && backlist; i++, backlist = backlist->next)
-    /* FIXME: For closures we should ignore the environment.  */
-    ASET (backtrace, i, backlist->function);
-
-  /* Make sure that unused space of working memory is filled with nil.  */
-  for (; i < asize; i++)
-    ASET (backtrace, i, Qnil);
+  get_backtrace (backtrace);
 
   { /* We basically do a `gethash+puthash' here, except that we have to be
        careful to avoid memory allocation since we're in a signal
@@ -232,7 +221,7 @@ static EMACS_INT current_sampling_interval;
 static void
 handle_profiler_signal (int signal)
 {
-  if (backtrace_list && EQ (backtrace_list->function, Qautomatic_gc))
+  if (EQ (backtrace_top_function (), Qautomatic_gc))
     /* Special case the time-count inside GC because the hash-table
        code is not prepared to be used while the GC is running.
        More specifically it uses ASIZE at many places where it does
diff --git a/src/puresize.h b/src/puresize.h
index 2f717571c7c..25a11aafbcc 100644
--- a/src/puresize.h
+++ b/src/puresize.h
@@ -73,9 +73,9 @@ along with GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.  */
 /* Signal an error if OBJ is pure.  */
 #define CHECK_IMPURE(obj) \
   { if (PURE_P (obj))     \
-      pure_write_error (); }
+      pure_write_error (obj); }
 
-extern _Noreturn void pure_write_error (void);
+extern _Noreturn void pure_write_error (Lisp_Object);
 
 /* Define PURE_P.  */
 
diff --git a/src/term.c b/src/term.c
index 28b944c6436..0bcef55947a 100644
--- a/src/term.c
+++ b/src/term.c
@@ -3189,12 +3189,13 @@ use the Bourne shell command `TERM=... export TERM' (C-shell:\n\
 #ifdef WINDOWSNT
   {
     struct frame *f = XFRAME (selected_frame);
+    int height, width;
 
-    initialize_w32_display (terminal);
+    initialize_w32_display (terminal, &width, &height);
 
-    FrameRows (tty) = FRAME_LINES (f);
-    FrameCols (tty) = FRAME_COLS (f);
-    tty->specified_window = FRAME_LINES (f);
+    FrameRows (tty) = height;
+    FrameCols (tty) = width;
+    tty->specified_window = height;
 
     FRAME_VERTICAL_SCROLL_BAR_TYPE (f) = vertical_scroll_bar_none;
     terminal->char_ins_del_ok = 1;
diff --git a/src/termhooks.h b/src/termhooks.h
index 252dbabb6f9..4f3fa9cb47f 100644
--- a/src/termhooks.h
+++ b/src/termhooks.h
@@ -212,7 +212,7 @@ enum event_kind
   , NS_NONKEY_EVENT
 #endif
 
-#if defined (HAVE_INOTIFY) || defined (HAVE_NTGUI)
+#ifdef USE_FILE_NOTIFY
   /* File or directory was changed.  */
   , FILE_NOTIFY_EVENT
 #endif
diff --git a/src/w32.c b/src/w32.c
index 7d63c73eb18..7a39a617ee3 100644
--- a/src/w32.c
+++ b/src/w32.c
@@ -2452,7 +2452,7 @@ get_emacs_configuration_options (void)
 
 /* Emulate gettimeofday (Ulrich Leodolter, 1/11/95).  */
 int
-gettimeofday (struct timeval *restrict tv, struct timezone *restrict tz)
+gettimeofday (struct timeval *__restrict tv, struct timezone *__restrict tz)
 {
   struct _timeb tb;
   _ftime (&tb);
diff --git a/src/w32console.c b/src/w32console.c
index 06b2c7aa24e..ee92a593301 100644
--- a/src/w32console.c
+++ b/src/w32console.c
@@ -601,7 +601,7 @@ w32_face_attributes (struct frame *f, int face_id)
 }
 
 void
-initialize_w32_display (struct terminal *term)
+initialize_w32_display (struct terminal *term, int *width, int *height)
 {
   CONSOLE_SCREEN_BUFFER_INFO    info;
   Mouse_HLInfo *hlinfo;
@@ -722,23 +722,21 @@ initialize_w32_display (struct terminal *term)
               || info.srWindow.Right - info.srWindow.Left < 40
               || info.srWindow.Right - info.srWindow.Left > 100)))
     {
-      FRAME_LINES (SELECTED_FRAME ()) = 25;
-      SET_FRAME_COLS (SELECTED_FRAME (), 80);
+      *height = 25;
+      *width = 80;
     }
 
   else if (w32_use_full_screen_buffer)
     {
-      FRAME_LINES (SELECTED_FRAME ()) = info.dwSize.Y;  /* lines per page */
-      SET_FRAME_COLS (SELECTED_FRAME (), info.dwSize.X);  /* characters per line */
+      *height = info.dwSize.Y;  /* lines per page */
+      *width = info.dwSize.X;   /* characters per line */
     }
   else
     {
       /* Lines per page.  Use buffer coords instead of buffer size.  */
-      FRAME_LINES (SELECTED_FRAME ()) = 1 + info.srWindow.Bottom -
-        info.srWindow.Top;
+      *height = 1 + info.srWindow.Bottom - info.srWindow.Top;
       /* Characters per line.  Use buffer coords instead of buffer size.  */
-      SET_FRAME_COLS (SELECTED_FRAME (), 1 + info.srWindow.Right -
-                       info.srWindow.Left);
+      *width = 1 + info.srWindow.Right - info.srWindow.Left;
     }
 
   if (os_subtype == OS_NT)
diff --git a/src/w32inevt.c b/src/w32inevt.c
index 3c38cf806e8..88a3f9739cd 100644
--- a/src/w32inevt.c
+++ b/src/w32inevt.c
@@ -577,6 +577,7 @@ maybe_generate_resize_event (void)
                      0, 0, 0);
 }
 
+#if HAVE_W32NOTIFY
 static int
 handle_file_notifications (struct input_event *hold_quit)
 {
@@ -644,6 +645,13 @@ handle_file_notifications (struct input_event *hold_quit)
   leave_crit ();
   return nevents;
 }
+#else  /* !HAVE_W32NOTIFY */
+static int
+handle_file_notifications (struct input_event *hold_quit)
+{
+  return 0;
+}
+#endif  /* !HAVE_W32NOTIFY */
 
 /* Here's an overview of how Emacs input works in non-GUI sessions on
    MS-Windows.  (For description of the GUI input, see the commentary
diff --git a/src/w32term.c b/src/w32term.c
index 58b1d3ca308..617492e189f 100644
--- a/src/w32term.c
+++ b/src/w32term.c
@@ -3210,6 +3210,8 @@ construct_drag_n_drop (struct input_event *result, W32Msg *msg, struct frame *f)
 }
 
 
+#if HAVE_W32NOTIFY
+
 /* File event notifications (see w32notify.c).  */
 
 Lisp_Object
@@ -3325,7 +3327,8 @@ queue_notifications (struct input_event *event, W32Msg *msg, struct frame *f,
   /* We've stuffed all the events ourselves, so w32_read_socket shouldn't.  */
   event->kind = NO_EVENT;
 }
-#endif
+#endif  /* WINDOWSNT */
+#endif  /* HAVE_W32NOTIFY */
 
 
 /* Function to report a mouse movement to the mainstream Emacs code.
@@ -4968,7 +4971,7 @@ w32_read_socket (struct terminal *terminal,
           check_visibility = 1;
           break;
 
-#ifdef WINDOWSNT
+#if HAVE_W32NOTIFY
         case WM_EMACS_FILENOTIFY:
           f = x_window_to_frame (dpyinfo, msg.msg.hwnd);
           if (f)
diff --git a/src/w32term.h b/src/w32term.h
index 9c27c09d03d..be0b4a6f350 100644
--- a/src/w32term.h
+++ b/src/w32term.h
@@ -683,7 +683,7 @@ extern Lisp_Object w32_get_watch_object (void *);
 extern Lisp_Object lispy_file_action (DWORD);
 
 extern void w32_initialize_display_info (Lisp_Object);
-extern void initialize_w32_display (struct terminal *);
+extern void initialize_w32_display (struct terminal *, int *, int *);
 
 /* Keypad command key support.  W32 doesn't have virtual keys defined
    for the function keys on the keypad (they are mapped to the standard
diff --git a/src/xdisp.c b/src/xdisp.c
index 9f3be44ecfd..5ae15cbd0b3 100644
--- a/src/xdisp.c
+++ b/src/xdisp.c
@@ -12846,7 +12846,6 @@ redisplay_internal (void)
   struct frame *sf;
   int polling_stopped_here = 0;
   Lisp_Object tail, frame;
-  struct backtrace backtrace;
 
   /* Non-zero means redisplay has to consider all windows on all
      frames.  Zero means, only selected_window is considered.  */
@@ -12890,12 +12889,7 @@ redisplay_internal (void)
   specbind (Qinhibit_free_realized_faces, Qnil);
 
   /* Record this function, so it appears on the profiler's backtraces.  */
-  backtrace.next = backtrace_list;
-  backtrace.function = Qredisplay_internal;
-  backtrace.args = &Qnil;
-  backtrace.nargs = 0;
-  backtrace.debug_on_exit = 0;
-  backtrace_list = &backtrace;
+  record_in_backtrace (Qredisplay_internal, &Qnil, 0);
 
   FOR_EACH_FRAME (tail, frame)
     XFRAME (frame)->already_hscrolled_p = 0;
@@ -13532,7 +13526,6 @@ redisplay_internal (void)
 #endif /* HAVE_WINDOW_SYSTEM */
 
  end_of_redisplay:
-  backtrace_list = backtrace.next;
   unbind_to (count, Qnil);
   RESUME_POLLING;
 }
diff --git a/src/xgselect.c b/src/xgselect.c
index 0b5ad6ae70d..38b9705e976 100644
--- a/src/xgselect.c
+++ b/src/xgselect.c
@@ -21,7 +21,7 @@ along with GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.  */
 
 #include "xgselect.h"
 
-#if defined (USE_GTK) || defined (HAVE_GCONF) || defined (HAVE_GSETTINGS)
+#ifdef HAVE_GLIB
 
 #include <glib.h>
 #include <errno.h>
@@ -140,4 +140,4 @@ xg_select (int fds_lim, SELECT_TYPE *rfds, SELECT_TYPE *wfds, SELECT_TYPE *efds,
 
   return retval;
 }
-#endif /* USE_GTK || HAVE_GCONF || HAVE_GSETTINGS */
+#endif /* HAVE_GLIB */