some conflict resolution

49 files changed, 2209 insertions, 203 deletions

diff --git a/ChangeLog b/ChangeLog
index eb572b26b16..05bc063624b 100644
--- a/ChangeLog
+++ b/ChangeLog
@@ -1,3 +1,27 @@
+2012-12-11  Juanma Barranquero  <lekktu@gmail.com>
+
+        * lib/makefile.w32-in (SIG2STR_H): New macro.
+        ($(BLD)/sig2str.$(O)): Update dependencies.
+
+2012-12-10  Paul Eggert  <eggert@cs.ucla.edu>
+
+        * configure.ac (HAVE_INOTIFY): Speed up configure-time test.
+        There's no need to test for any of three inotify functions,
+        since we use all three.  Check for just the first one.
+
+2012-12-10  Daniel Colascione  <dancol@dancol.org>
+
+        * .bzrignore: add src/emacs.res.
+
+        * configure.ac (W32_RES, W32_RES_LINK, WINDRES): Teach the cygw32
+        build how to compile Windows resource files; use these variables
+        to tell src/Makefile.in how and whether to compile resources.
+
+2012-12-10  Rüdiger Sonderfeld  <ruediger@c-plusplus.de>
+
+        * configure.ac (inotify): New option.
+        (HAVE_INOTIFY): Test for inotify.
+
 2012-12-09  Andreas Schwab  <schwab@linux-m68k.org>
 
         * configure.ac: Fix source command in .gdbinit.
diff --git a/configure.ac b/configure.ac
index e649b6725e9..5b889cb2d8a 100644
--- a/configure.ac
+++ b/configure.ac
@@ -185,6 +185,7 @@ OPTION_DEFAULT_ON([gconf],[don't compile with GConf support])
 OPTION_DEFAULT_ON([gsettings],[don't compile with GSettings support])
 OPTION_DEFAULT_ON([selinux],[don't compile with SELinux support])
 OPTION_DEFAULT_ON([gnutls],[don't use -lgnutls for SSL/TLS support])
+OPTION_DEFAULT_ON([inotify],[don't compile with inotify (file-watch) support])
 
 OPTION_DEFAULT_OFF([xwidgets],[enable use of some gtk widgets it Emacs buffers])
 
@@ -1607,6 +1608,8 @@ AC_SUBST(LIB_STANDARD)
 HAVE_W32=no
 W32_OBJ=
 W32_LIBS=
+W32_RES=
+W32_RES_LINK=
 if test "${with_w32}" != no; then
   if test "${opsys}" != "cygwin"; then
     AC_MSG_ERROR([Using w32 with an autotools build is only supported for Cygwin.])
@@ -1615,13 +1618,21 @@ if test "${with_w32}" != no; then
                   [AC_MSG_ERROR([`--with-w32' was specified, but windows.h
                   cannot be found.])])
   AC_DEFINE(HAVE_NTGUI, 1, [Define to use native MS Windows GUI.])
+  AC_CHECK_TOOL(WINDRES, [windres],
+                [AC_MSG_ERROR([No resource compiler found.])])
   W32_OBJ="w32fns.o w32menu.o w32reg.o w32font.o w32term.o"
   W32_OBJ="$W32_OBJ w32xfns.o w32select.o w32uniscribe.o"
   W32_LIBS="$W32_LIBS -lkernel32 -luser32 -lgdi32 -lole32 -lcomdlg32"
   W32_LIBS="$W32_LIBS -lusp10 -lcomctl32 -lwinspool"
+  W32_RES="emacs.res"
+  # Tell the linker that emacs.res is an object (which we compile from
+  # the rc file), not a linker script.
+  W32_RES_LINK="-Wl,-bpe-i386 -Wl,emacs.res"
 fi
 AC_SUBST(W32_OBJ)
 AC_SUBST(W32_LIBS)
+AC_SUBST(W32_RES)
+AC_SUBST(W32_RES_LINK)
 
 if test "${HAVE_W32}" = "yes"; then
   window_system=w32
@@ -2236,6 +2247,17 @@ fi
 AC_SUBST(LIBGNUTLS_LIBS)
 AC_SUBST(LIBGNUTLS_CFLAGS)
 
+dnl inotify is only available on GNU/Linux.
+if test "${with_inotify}" = "yes"; then
+   AC_CHECK_HEADERS(sys/inotify.h)
+   if test "$ac_cv_header_sys_inotify_h" = yes ; then
+     AC_CHECK_FUNC(inotify_init1)
+   fi
+fi
+if test "$ac_cv_func_inotify_init1" = yes; then
+  AC_DEFINE(HAVE_INOTIFY, 1, [Define to 1 to use inotify.])
+fi
+
 dnl Do not put whitespace before the #include statements below.
 dnl Older compilers (eg sunos4 cc) choke on it.
 HAVE_XAW3D=no
diff --git a/doc/lispref/ChangeLog b/doc/lispref/ChangeLog
index 05716cd77b3..43d737b618f 100644
--- a/doc/lispref/ChangeLog
+++ b/doc/lispref/ChangeLog
@@ -1,3 +1,9 @@
+2012-12-11  Paul Eggert  <eggert@cs.ucla.edu>
+
+        * internals.texi (C Integer Types): New section.
+        This follows up and records an email in
+        <http://lists.gnu.org/archive/html/emacs-devel/2012-07/msg00496.html>.
+
 2012-12-10  Stefan Monnier  <monnier@iro.umontreal.ca>
 
         * control.texi (Pattern maching case statement): New node.
diff --git a/doc/lispref/internals.texi b/doc/lispref/internals.texi
index 830a00ec9e6..025042a6869 100644
--- a/doc/lispref/internals.texi
+++ b/doc/lispref/internals.texi
@@ -16,6 +16,7 @@ internal aspects of GNU Emacs that may be of interest to C programmers.
 * Memory Usage::        Info about total size of Lisp objects made so far.
 * Writing Emacs Primitives::   Writing C code for Emacs.
 * Object Internals::    Data formats of buffers, windows, processes.
+* C Integer Types::     How C integer types are used inside Emacs.
 @end menu
 
 @node Building Emacs
@@ -1531,4 +1532,91 @@ Symbol indicating the type of process: @code{real}, @code{network},
 
 @end table
 
+@node C Integer Types
+@section C Integer Types
+@cindex integer types (C programming language)
+
+Here are some guidelines for use of integer types in the Emacs C
+source code.  These guidelines sometimes give competing advice; common
+sense is advised.
+
+@itemize @bullet
+@item
+Avoid arbitrary limits.  For example, avoid @code{int len = strlen
+(s);} unless the length of @code{s} is required for other reasons to
+fit in @code{int} range.
+
+@item
+Do not assume that signed integer arithmetic wraps around on overflow.
+This is no longer true of Emacs porting targets: signed integer
+overflow has undefined behavior in practice, and can dump core or
+even cause earlier or later code to behave ``illogically''.  Unsigned
+overflow does wrap around reliably, modulo a power of two.
+
+@item
+Prefer signed types to unsigned, as code gets confusing when signed
+and unsigned types are combined.  Many other guidelines assume that
+types are signed; in the rarer cases where unsigned types are needed,
+similar advice may apply to the unsigned counterparts (e.g.,
+@code{size_t} instead of @code{ptrdiff_t}, or @code{uintptr_t} instead
+of @code{intptr_t}).
+
+@item
+Prefer @code{int} for Emacs character codes, in the range 0 ..@: 0x3FFFFF.
+
+@item
+Prefer @code{ptrdiff_t} for sizes, i.e., for integers bounded by the
+maximum size of any individual C object or by the maximum number of
+elements in any C array.  This is part of Emacs's general preference
+for signed types.  Using @code{ptrdiff_t} limits objects to
+@code{PTRDIFF_MAX} bytes, but larger objects would cause trouble
+anyway since they would break pointer subtraction, so this does not
+impose an arbitrary limit.
+
+@item
+Prefer @code{intptr_t} for internal representations of pointers, or
+for integers bounded only by the number of objects that can exist at
+any given time or by the total number of bytes that can be allocated.
+Currently Emacs sometimes uses other types when @code{intptr_t} would
+be better; fixing this is lower priority, as the code works as-is on
+Emacs's current porting targets.
+
+@item
+Prefer the Emacs-defined type @code{EMACS_INT} for representing values
+converted to or from Emacs Lisp fixnums, as fixnum arithmetic is based
+on @code{EMACS_INT}.
+
+@item
+When representing a system value (such as a file size or a count of
+seconds since the Epoch), prefer the corresponding system type (e.g.,
+@code{off_t}, @code{time_t}).  Do not assume that a system type is
+signed, unless this assumption is known to be safe.  For example,
+although @code{off_t} is always signed, @code{time_t} need not be.
+
+@item
+Prefer the Emacs-defined type @code{printmax_t} for representing
+values that might be any signed integer value that can be printed,
+using a @code{printf}-family function.
+
+@item
+Prefer @code{intmax_t} for representing values that might be any
+signed integer value.
+
+@item
+In bitfields, prefer @code{unsigned int} or @code{signed int} to
+@code{int}, as @code{int} is less portable: it might be signed, and
+might not be.  Single-bit bit fields are invariably @code{unsigned
+int} so that their values are 0 and 1.
+
+@item
+In C, Emacs commonly uses @code{bool}, 1, and 0 for boolean values.
+Using @code{bool} for booleans can make programs easier to read and a
+bit faster than using @code{int}.  Although it is also OK to use
+@code{int}, this older style is gradually being phased out.  When
+using @code{bool}, respect the limitations of the replacement
+implementation of @code{bool}, as documented in the source file
+@file{lib/stdbool.in.h}, so that Emacs remains portable to pre-C99
+platforms.
+@end itemize
+
 @c FIXME Mention src/globals.h somewhere in this file?
diff --git a/etc/NEWS b/etc/NEWS
index c7622b09b6b..77e7e47b8a3 100644
--- a/etc/NEWS
+++ b/etc/NEWS
@@ -133,6 +133,12 @@ spurious warnings about an unused var.
 
 * Lisp changes in Emacs 24.4
 
+** Support for filesystem notifications.
+Emacs now supports notifications of filesystem changes, such as
+creation, modification, and deletion of files.  This requires the
+'inotify' API on GNU/Linux systems.  On MS-Windows systems, this is
+supported for Windows XP and newer versions.
+
 ** Face changes
 
 *** The `face-spec-set' is now analogous to `setq' for face specs.
diff --git a/lib-src/ChangeLog b/lib-src/ChangeLog
index 480ddabd44a..866e76ad24f 100644
--- a/lib-src/ChangeLog
+++ b/lib-src/ChangeLog
@@ -1,3 +1,12 @@
+2012-12-11  Juanma Barranquero  <lekktu@gmail.com>
+
+        * makefile.w32-in (SYSWAIT_H): Update dependencies.
+
+2012-12-10  Eli Zaretskii  <eliz@gnu.org>
+
+        * makefile.w32-in (obj): Add w32notify.o.  Add missing X and Unix
+        sources.
+
 2012-12-02  Kevin Ryde  <user42@zip.com.au>
 
         * etags.c (Lisp_functions): Skip (defvar foo) declarations unless
diff --git a/lib-src/makefile.w32-in b/lib-src/makefile.w32-in
index cbd29f32cfe..24be44e22f2 100644
--- a/lib-src/makefile.w32-in
+++ b/lib-src/makefile.w32-in
@@ -123,10 +123,13 @@ $(BLD)/profile.exe:	$(PROFILEOBJS)
 #
 obj =   dosfns.o msdos.o \
         xterm.o xfns.o xmenu.o xselect.o xrdb.o xsmfns.o fringe.o image.o \
-        fontset.o menu.o \
-        w32.o w32console.o w32fns.o w32heap.o w32inevt.o cygw32.o \
+        fontset.o menu.o dbusbind.o cygw32.o \
+        nsterm.o nsfns.o nsmenu.o nsselect.o nsimage.o nsfont.o \
+        w32.o w32console.o w32fns.o w32heap.o w32inevt.o w32notify.o \
         w32menu.o w32proc.o w32reg.o w32select.o w32term.o w32xfns.o \
-        font.o w32font.o w32uniscribe.o \
+        w16select.o widget.o xfont.o ftfont.o xftfont.o ftxfont.o gtkutil.o \
+        xsettings.o xgselect.o termcap.o \
+        font.o w32font.o w32uniscribe.o w32notify.o \
         dispnew.o frame.o scroll.o xdisp.o window.o bidi.o \
         charset.o coding.o category.o ccl.o character.o chartab.o \
         cm.o term.o terminal.o xfaces.o \
@@ -375,6 +378,7 @@ SYSTIME_H      = $(SRC)/systime.h \
                  $(NT_INC)/sys/time.h \
                  $(GNU_LIB)/timespec.h
 SYSWAIT_H      = $(SRC)/syswait.h \
+                 $(NT_INC)/stdbool.h \
                  $(NT_INC)/sys/wait.h
 
 $(BLD)/ctags.$(O) : \
diff --git a/lib/makefile.w32-in b/lib/makefile.w32-in
index b27e21032b3..1482d686acb 100644
--- a/lib/makefile.w32-in
+++ b/lib/makefile.w32-in
@@ -103,6 +103,8 @@ U64_H          = $(GNU_LIB)/u64.h \
                  $(NT_INC)/stdint.h
 SHA512_H       = $(GNU_LIB)/sha512.h \
                  $(U64_H)
+SIG2STR_H      = $(GNU_LIB)/sig2str.h \
+                 $(GNU_LIB)/intprops.h
 STAT_TIME_H    = $(GNU_LIB)/stat-time.h \
                  $(NT_INC)/sys/stat.h
 
@@ -243,8 +245,7 @@ $(BLD)/filemode.$(O) : \
 $(BLD)/sig2str.$(O) : \
         $(GNU_LIB)/sig2str.c \
         $(CONFIG_H) \
-        $(GNU_LIB)/sig2str.h \
-        $(GNU_LIB)/intprops.h
+        $(SIG2STR_H)
 
 
 # The following dependencies are for supporting parallel builds, where
diff --git a/lisp/ChangeLog b/lisp/ChangeLog
index 787bfb7563b..17dc012fdab 100644
--- a/lisp/ChangeLog
+++ b/lisp/ChangeLog
@@ -1,11 +1,59 @@
+2012-12-11  Eli Zaretskii  <eliz@gnu.org>
+
+        * makefile.w32-in (compile4-SH): Fix a typo that caused term
+        subdirectory be skipped.
+
+2012-12-11  Glenn Morris  <rgm@gnu.org>
+
+        * net/rcirc.el (rcirc-urls, rcirc-condition-filter): Doc fixes.
+
+        * progmodes/f90.el (f90-line-continued, f90-indent-region):
+        Treat preprocessor lines embedded in continuations like comments.
+        (f90-indent-line): Special-case preprocessor lines.  (Bug#13138)
+
+2012-12-11  Jay Belanger  <jay.p.belanger@gmail.com>
+
+        * calc/calc.el (calc-standard-date-formats):  Add more date
+        formats.
+        * calc/calc-forms.el (math-parse-iso-date): New function.
+        (math-parse-date): Use `math-parse-iso-date' when appropriate.
+        (math-parse-iso-date-validate): Add extra error checking.
+        (calc-date-notation): Add ability to access new date formats.
+
+2012-12-10  Stefan Monnier  <monnier@iro.umontreal.ca>
+
+        * hi-lock.el (hi-lock--regexps-at-point): Fix boundary case for
+        font-lock as well as when there's no text-property.
+
+2012-12-10  Jambunathan K  <kjambunathan@gmail.com>
+
+        * hi-lock.el: Refine the choice of default face.
+        (hi-lock-keyword->face): New function.  Use it wherever we used
+        cadadadr instead.
+        (hi-lock--regexps-at-point): Ignore faces that can't come from hi-lock.
+        (hi-lock--last-face): Remove var.
+        (hi-lock--unused-faces): New var to replace it.
+        (hi-lock-read-face-name): Use/maintain it.
+        (hi-lock-unface-buffer): Maintain it.  Fix error for the C-u case.
+        (hi-lock-set-pattern): Ignore new rule if it has the same regexp even
+        if it has another face.
+
+2012-12-10  Eli Zaretskii  <eliz@gnu.org>
+
+        * subr.el (w32notify-handle-event): New function.
+        (inotify-handle-event): Doc fix.
+
+2012-12-10  Rüdiger Sonderfeld  <ruediger@c-plusplus.de>
+
+        * subr.el (inotify-event-p, inotify-handle-event): New functions.
+
 2012-12-10  Dani Moncayo <dmoncayo@gmail.com>
 
         * simple.el (just-one-space): Doc fix.
 
 2012-12-10  Eli Zaretskii  <eliz@gnu.org>
 
-        * textmodes/texinfo.el (texinfo-enable-quote-envs): Add
-        "smallexample".
+        * textmodes/texinfo.el (texinfo-enable-quote-envs): Add "smallexample".
 
 2012-12-10  Le Wang  <l26wang@gmail.com>
 
diff --git a/lisp/calc/calc-forms.el b/lisp/calc/calc-forms.el
index 5ce76b14d72..7cfca261fa3 100644
--- a/lisp/calc/calc-forms.el
+++ b/lisp/calc/calc-forms.el
@@ -82,13 +82,13 @@
   (calc-wrapper
    (if (string-match-p "\\`\\s-*\\'" fmt)
        (setq fmt "1"))
-   (if (string-match "\\` *[0-9] *\\'" fmt)
+   (if (string-match "\\` *\\([0-9]\\|10\\|11\\) *\\'" fmt)
        (setq fmt (nth (string-to-number fmt) calc-standard-date-formats)))
    (or (string-match "[a-zA-Z]" fmt)
        (error "Bad date format specifier"))
    (and arg
         (>= (setq arg (prefix-numeric-value arg)) 0)
-        (<= arg 9)
+        (<= arg 11)
         (setq calc-standard-date-formats
               (copy-sequence calc-standard-date-formats))
         (setcar (nthcdr arg calc-standard-date-formats) fmt))
@@ -918,6 +918,8 @@ as measured in the integer number of days before December 31, 1 BC (Gregorian)."
   (catch 'syntax
     (or (math-parse-standard-date math-pd-str t)
         (math-parse-standard-date math-pd-str nil)
+        (and (or (memq 'IYYY calc-date-format) (memq 'Iww calc-date-format))
+             (math-parse-iso-date math-pd-str))
         (and (string-match "\\`[^-+/0-9a-zA-Z]*\\([-+]?[0-9]+\\.?[0-9]*\\([eE][-+]?[0-9]+\\)?\\)[^-+/0-9a-zA-Z]*\\'" math-pd-str)
              (list 'date (math-read-number (math-match-substring math-pd-str 1))))
         (let ((case-fold-search t)
@@ -1085,6 +1087,8 @@ as measured in the integer number of days before December 31, 1 BC (Gregorian)."
 (defun math-parse-iso-date-validate (isoyear isoweek isoweekday hour minute second)
   (if (or (< isoweek 1) (> isoweek 53))
       (throw 'syntax "Week value is out of range"))
+  (if (or (< isoweekday 1) (> isoweekday 7))
+      (throw 'syntax "Weekday value is out of range"))
   (and hour
        (progn
          (if (or (< hour 0) (> hour 23))
@@ -1290,6 +1294,31 @@ as measured in the integer number of days before December 31, 1 BC (Gregorian)."
                      (setq day (math-add day (1- yearday))))
                  day))))))
 
+(defun math-parse-iso-date (math-pd-str)
+  "Parse MATH-PD-STR as an ISO week date, or return nil."
+  (let ((case-fold-search t)
+        (isoyear nil) (isoweek nil) (isoweekday nil)
+        (hour nil) (minute nil) (second nil))
+    ;; Extract the time, if any.
+    (if (string-match "T[^0-9]*\\([0-9][0-9]\\)[^0-9]*\\([0-9][0-9]\\)?[^0-9]*\\([0-9][0-9]\\(\\.[0-9]+\\)?\\)?" math-pd-str)
+        (progn
+          (setq hour (string-to-number (math-match-substring math-pd-str 1))
+                minute (math-match-substring math-pd-str 2)
+                second (math-match-substring math-pd-str 3)
+                math-pd-str (substring math-pd-str 0 (match-beginning 0)))
+          (if (equal minute "")
+              (setq minute 0)
+            (setq minute (string-to-number minute)))
+          (if (equal second "")
+              (setq second 0)
+            (setq second (math-read-number second)))))
+    ;; Next, the year, week and weekday
+    (if (string-match "\\(-?[0-9]*\\)[^0-9]*W\\([0-9][0-9]\\)[^0-9]*\\([0-9]\\)[^0-9]*\\'" math-pd-str)
+        (progn
+          (setq isoyear (string-to-number (math-match-substring math-pd-str 1))
+                isoweek (string-to-number (math-match-substring math-pd-str 2))
+                isoweekday (string-to-number (math-match-substring math-pd-str 3)))
+          (math-parse-iso-date-validate isoyear isoweek isoweekday hour minute second)))))
 
 (defun calcFunc-now (&optional zone)
   (let ((date (let ((calc-date-format nil))
diff --git a/lisp/calc/calc.el b/lisp/calc/calc.el
index 58eabf9bcec..b89cfbbda36 100644
--- a/lisp/calc/calc.el
+++ b/lisp/calc/calc.el
@@ -787,7 +787,9 @@ If nil, selections displayed but ignored.")
     "M-D-Y< H:mm:SSpp>"
     "D-M-Y< h:mm:SS>"
     "j<, h:mm:SS>"
-    "YYddd< hh:mm:ss>"))
+    "YYddd< hh:mm:ss>"
+    "ZYYY-MM-DD Www< hh:mm>"
+    "IYYY-Iww-w< Thh:mm:ss>"))
 
 (defcalcmodevar calc-autorange-units nil
   "If non-nil, automatically set unit prefixes to keep units in a reasonable range.")
diff --git a/lisp/hi-lock.el b/lisp/hi-lock.el
index de875c72593..2ae328a09e8 100644
--- a/lisp/hi-lock.el
+++ b/lisp/hi-lock.el
@@ -462,6 +462,9 @@ updated as you type."
   (unless hi-lock-mode (hi-lock-mode 1))
   (hi-lock-set-pattern regexp face))
 
+(defun hi-lock-keyword->face (keyword)
+  (cadr (cadr (cadr keyword))))    ; Keyword looks like (REGEXP (0 'FACE) ...).
+
 (declare-function x-popup-menu "menu.c" (position menu))
 
 (defun hi-lock--regexps-at-point ()
@@ -470,23 +473,39 @@ updated as you type."
     ;; choice of regexp.
     (let ((regexp (get-char-property (point) 'hi-lock-overlay-regexp)))
       (when regexp (push regexp regexps)))
-    ;; With font-locking on, check if the cursor is on an highlighted text.
-    ;; Checking for hi-lock face is a good heuristic.  FIXME: use "hi-lock-".
-    (and (string-match "\\`hi-" (face-name (face-at-point)))
-         (let* ((hi-text
-                 (buffer-substring-no-properties
-                  (previous-single-property-change (point) 'face)
-                  (next-single-property-change (point) 'face))))
-           ;; Compute hi-lock patterns that match the
-           ;; highlighted text at point.  Use this later in
-           ;; during completing-read.
-           (dolist (hi-lock-pattern hi-lock-interactive-patterns)
-             (let ((regexp (car hi-lock-pattern)))
-               (if (string-match regexp hi-text)
-                   (push regexp regexps))))))
+    ;; With font-locking on, check if the cursor is on a highlighted text.
+    (let ((face-after (get-text-property (point) 'face))
+          (face-before
+           (unless (bobp) (get-text-property (1- (point)) 'face)))
+          (faces (mapcar #'hi-lock-keyword->face
+                         hi-lock-interactive-patterns)))
+      (unless (memq face-before faces) (setq face-before nil))
+      (unless (memq face-after faces) (setq face-after nil))
+      (when (and face-before face-after (not (eq face-before face-after)))
+        (setq face-before nil))
+      (when (or face-after face-before)
+        (let* ((hi-text
+                (buffer-substring-no-properties
+                 (if face-before
+                     (or (previous-single-property-change (point) 'face)
+                         (point-min))
+                   (point))
+                 (if face-after
+                     (or (next-single-property-change (point) 'face)
+                         (point-max))
+                   (point)))))
+          ;; Compute hi-lock patterns that match the
+          ;; highlighted text at point.  Use this later in
+          ;; during completing-read.
+          (dolist (hi-lock-pattern hi-lock-interactive-patterns)
+            (let ((regexp (car hi-lock-pattern)))
+              (if (string-match regexp hi-text)
+                  (push regexp regexps)))))))
     regexps))
 
-(defvar-local hi-lock--last-face nil)
+(defvar-local hi-lock--unused-faces nil
+  "List of faces that is not used and is available for highlighting new text.
+Face names from this list come from `hi-lock-face-defaults'.")
 
 ;;;###autoload
 (defalias 'unhighlight-regexp 'hi-lock-unface-buffer)
@@ -514,7 +533,7 @@ then remove all hi-lock highlighting."
                           (list (car pattern)
                                 (format
                                  "%s (%s)" (car pattern)
-                                 (cadr (cadr (cadr pattern))))
+                                 (hi-lock-keyword->face pattern))
                                 (cons nil nil)
                                 (car pattern)))
                         hi-lock-interactive-patterns))))
@@ -541,16 +560,14 @@ then remove all hi-lock highlighting."
   (dolist (keyword (if (eq regexp t) hi-lock-interactive-patterns
                      (list (assoc regexp hi-lock-interactive-patterns))))
     (when keyword
-      (let ((face (cadr (cadr (cadr keyword)))))
+      (let ((face (hi-lock-keyword->face keyword)))
         ;; Make `face' the next one to use by default.
-        (setq hi-lock--last-face
-              (cadr (member (symbol-name face)
-                            (reverse hi-lock-face-defaults)))))
+        (add-to-list 'hi-lock--unused-faces (face-name face)))
       (font-lock-remove-keywords nil (list keyword))
       (setq hi-lock-interactive-patterns
             (delq keyword hi-lock-interactive-patterns))
       (remove-overlays
-       nil nil 'hi-lock-overlay-regexp (hi-lock--hashcons regexp))
+       nil nil 'hi-lock-overlay-regexp (hi-lock--hashcons (car keyword)))
       (when font-lock-fontified (font-lock-fontify-buffer)))))
 
 ;;;###autoload
@@ -608,27 +625,35 @@ not suitable."
   "Return face for interactive highlighting.
 When `hi-lock-auto-select-face' is non-nil, just return the next face.
 Otherwise, read face name from minibuffer with completion and history."
-  (let ((default (or (cadr (member hi-lock--last-face hi-lock-face-defaults))
-                      (car hi-lock-face-defaults))))
-    (setq hi-lock--last-face
+  (unless hi-lock-interactive-patterns
+    (setq hi-lock--unused-faces hi-lock-face-defaults))
+  (let* ((last-used-face
+          (when hi-lock-interactive-patterns
+            (face-name (hi-lock-keyword->face
+                        (car hi-lock-interactive-patterns)))))
+         (defaults (append hi-lock--unused-faces
+                           (cdr (member last-used-face hi-lock-face-defaults))
+                           hi-lock-face-defaults))
+         face)
           (if (and hi-lock-auto-select-face (not current-prefix-arg))
-              default
-            (completing-read
-             (format "Highlight using face (default %s): " default)
-             obarray 'facep t nil 'face-name-history
-             (append (member default hi-lock-face-defaults)
-                     hi-lock-face-defaults))))
-    (unless (member hi-lock--last-face hi-lock-face-defaults)
-      (setq hi-lock-face-defaults
-            (append hi-lock-face-defaults (list hi-lock--last-face))))
-    (intern hi-lock--last-face)))
+        (setq face (or (pop hi-lock--unused-faces) (car defaults)))
+      (setq face (completing-read
+                  (format "Highlight using face (default %s): "
+                          (car defaults))
+                  obarray 'facep t nil 'face-name-history defaults))
+      ;; Update list of un-used faces.
+      (setq hi-lock--unused-faces (remove face hi-lock--unused-faces))
+      ;; Grow the list of defaults.
+      (add-to-list 'hi-lock-face-defaults face t))
+    (intern face)))
 
 (defun hi-lock-set-pattern (regexp face)
   "Highlight REGEXP with face FACE."
   ;; Hashcons the regexp, so it can be passed to remove-overlays later.
   (setq regexp (hi-lock--hashcons regexp))
   (let ((pattern (list regexp (list 0 (list 'quote face) t))))
-    (unless (member pattern hi-lock-interactive-patterns)
+    ;; Refuse to highlight a text that is already highlighted.
+    (unless (assoc regexp hi-lock-interactive-patterns)
       (push pattern hi-lock-interactive-patterns)
       (if font-lock-mode
           (progn
diff --git a/lisp/makefile.w32-in b/lisp/makefile.w32-in
index cb2cba466f6..b6beb6b292a 100644
--- a/lisp/makefile.w32-in
+++ b/lisp/makefile.w32-in
@@ -387,7 +387,7 @@ compile3-SH: autoloads compile0-SH
         done
 
 compile4-SH: autoloads compile0-SH
-        for dir in $(WINS_BASIC4) $(WINS_CEDET) terms obsolete; do \
+        for dir in $(WINS_BASIC4) $(WINS_CEDET) term obsolete; do \
           for el in $$dir/*.el; do \
             if test -f $$el; \
             then \
diff --git a/lisp/net/rcirc.el b/lisp/net/rcirc.el
index fa5bc4a9822..16644b57549 100644
--- a/lisp/net/rcirc.el
+++ b/lisp/net/rcirc.el
@@ -406,8 +406,7 @@ will be killed."
   "The channel or user associated with this buffer.")
 
 (defvar rcirc-urls nil
-  "List of URLs seen in the current buffer and the position in
-the buffer where the URL starts.")
+  "List of URLs seen in the current buffer and their start positions.")
 (put 'rcirc-urls 'permanent-local t)
 
 (defvar rcirc-timeout-seconds 600
@@ -2393,9 +2392,11 @@ keywords when no KEYWORD is given."
    "\\)")
   "Regexp matching URLs.  Set to nil to disable URL features in rcirc.")
 
+;; cf cl-remove-if-not
 (defun rcirc-condition-filter (condp lst)
-  "Given a condition and a list, returns the list with elements
-that do not satisfy the condition removed."
+  "Remove all items not satisfying condition CONDP in list LST.
+CONDP is a function that takes a list element as argument and returns
+non-nil if that element should be included.  Returns a new list."
   (delq nil (mapcar (lambda (x) (and (funcall condp x) x)) lst)))
 
 (defun rcirc-browse-url (&optional arg)
diff --git a/lisp/progmodes/f90.el b/lisp/progmodes/f90.el
index f42952685d0..59dda170b77 100644
--- a/lisp/progmodes/f90.el
+++ b/lisp/progmodes/f90.el
@@ -1178,11 +1178,11 @@ and lies before point."
 
 (defsubst f90-line-continued ()
   "Return t if the current line is a continued one.
-This includes comment lines embedded in continued lines, but
-not the last line of a continued statement."
+This includes comment or preprocessor lines embedded in continued lines,
+but not the last line of a continued statement."
   (save-excursion
     (beginning-of-line)
-    (while (and (looking-at "[ \t]*\\(!\\|$\\)") (zerop (forward-line -1))))
+    (while (and (looking-at "[ \t]*\\([!#]\\|$\\)") (zerop (forward-line -1))))
     (end-of-line)
     (while (f90-in-comment)
       (search-backward "!" (line-beginning-position))
@@ -1832,11 +1832,15 @@ after indenting."
         (f90-indent-line-no)
       (setq no-line-number t)
       (skip-chars-forward " \t"))
-    (if (looking-at "!")
-        (setq indent (f90-comment-indent))
-      (and f90-smart-end (looking-at "end")
-           (f90-match-end))
-      (setq indent (f90-calculate-indent)))
+    ;; FIXME This means f90-calculate-indent gives different answers
+    ;; for comments and preprocessor lines to this function.
+    ;; Better to make f90-calculate-indent return the correct answer?
+    (cond ((looking-at "!") (setq indent (f90-comment-indent)))
+          ((looking-at "#") (setq indent 0))
+          (t
+           (and f90-smart-end (looking-at "end")
+                (f90-match-end))
+           (setq indent (f90-calculate-indent))))
     (or (= indent (current-column))
         (f90-indent-to indent no-line-number))
     ;; If initial point was within line's indentation,
@@ -1973,12 +1977,13 @@ If run in the middle of a line, the line is not broken."
           (f90-indent-to ind-curr))
       (while (and (f90-line-continued) (zerop (forward-line 1))
                   (< (point) end-region-mark))
-        (if (looking-at "[ \t]*!")
-            (f90-indent-to (f90-comment-indent))
-          (or (= (current-indentation)
-                 (+ ind-curr f90-continuation-indent))
-              (f90-indent-to
-               (+ ind-curr f90-continuation-indent) 'no-line-no)))))
+        (cond ((looking-at "[ \t]*#") (f90-indent-to 0))
+              ((looking-at "[ \t]*!") (f90-indent-to (f90-comment-indent)))
+              (t
+               (or (= (current-indentation)
+                      (+ ind-curr f90-continuation-indent))
+                   (f90-indent-to
+                    (+ ind-curr f90-continuation-indent) 'no-line-no))))))
     ;; Restore point, etc.
     (setq f90-cache-position nil)
     (goto-char save-point)
diff --git a/lisp/subr.el b/lisp/subr.el
index e08277370a9..1e509036cd1 100644
--- a/lisp/subr.el
+++ b/lisp/subr.el
@@ -4323,6 +4323,36 @@ convenience wrapper around `make-progress-reporter' and friends.
        nil ,@(cdr (cdr spec)))))
 
 
+;;;; Support for watching filesystem events.
+
+(defun inotify-event-p (event)
+  "Check if EVENT is an inotify event."
+  (and (listp event)
+       (>= (length event) 3)
+       (eq (car event) 'file-inotify)))
+
+;;;###autoload
+(defun inotify-handle-event (event)
+  "Handle inotify file system monitoring event.
+If EVENT is an inotify filewatch event, call its callback.
+Otherwise, signal a `filewatch-error'."
+  (interactive "e")
+  (unless (inotify-event-p event)
+    (signal 'filewatch-error (cons "Not a valid inotify event" event)))
+  (funcall (nth 2 event) (nth 1 event)))
+
+(defun w32notify-handle-event (event)
+  "Handle MS-Windows file system monitoring event.
+If EVENT is an MS-Windows filewatch event, call its callback.
+Otherwise, signal a `filewatch-error'."
+  (interactive "e")
+  (if (and (eq (car event) 'file-w32notify)
+           (= (length event) 3))
+      (funcall (nth 2 event) (nth 1 event))
+    (signal 'filewatch-error
+            (cons "Not a valid MS-Windows file-notify event" event))))
+
+
 ;;;; Comparing version strings.
 
 (defconst version-separator "."
diff --git a/nt/ChangeLog b/nt/ChangeLog
index 35fcefe5b1b..ced3733da07 100644
--- a/nt/ChangeLog
+++ b/nt/ChangeLog
@@ -1,3 +1,15 @@
+2012-12-11  Juanma Barranquero  <lekktu@gmail.com>
+
+        * config.nt: Sync with autogen/config.in.
+        (HAVE_DECL_UNSETENV, HAVE_SIG2STR, VOID_UNSETENV): New macros.
+        (ULIMIT_BREAK_VALUE): Remove.
+
+2012-12-10  Daniel Colascione  <dancol@dancol.org>
+
+        * emacs.rc: Use forward slashes in relative paths in order to
+        avoid complaints from Cygwin.  (Forward slashes work perfectly
+        well in the NT build.)
+
 2012-12-09  Eli Zaretskii  <eliz@gnu.org>
 
         * inc/unistd.h (unsetenv): Provide a prototype.
diff --git a/nt/config.nt b/nt/config.nt
index e83c9ff655f..789a1a8b2af 100644
--- a/nt/config.nt
+++ b/nt/config.nt
@@ -325,6 +325,10 @@ along with GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.  */
    */
 #define HAVE_DECL_TZNAME 1
 
+/* Define to 1 if you have the declaration of `unsetenv', and to 0 if you
+   don't. */
+#undef HAVE_DECL_UNSETENV
+
 /* Define to 1 if you have the declaration of `__fpending', and to 0 if you
    don't. */
 #undef HAVE_DECL___FPENDING
@@ -790,6 +794,9 @@ along with GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.  */
 /* Define to 1 if you have the `shutdown' function. */
 #define HAVE_SHUTDOWN 1
 
+/* Define to 1 if you have the `sig2str' function. */
+#undef HAVE_SIG2STR
+
 /* Define to 1 if 'sig_atomic_t' is a signed integer type. */
 #undef HAVE_SIGNED_SIG_ATOMIC_T
 
@@ -990,12 +997,12 @@ along with GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.  */
 /* Define to 1 if you have the <unistd.h> header file. */
 #define HAVE_UNISTD_H 1
 
-/* Define to 1 if the system has the type 'unsigned long long int'. */
-#undef HAVE_UNSIGNED_LONG_LONG_INT
-
 /* Define to 1 if you have the `unsetenv' function. */
 #define HAVE_UNSETENV 1
 
+/* Define to 1 if the system has the type 'unsigned long long int'. */
+#undef HAVE_UNSIGNED_LONG_LONG_INT
+
 /* Define to 1 if you have the <util.h> header file. */
 #undef HAVE_UTIL_H
 
@@ -1338,9 +1345,6 @@ along with GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.  */
    timespec. */
 #undef TYPEOF_STRUCT_STAT_ST_ATIM_IS_STRUCT_TIMESPEC
 
-/* Undocumented. */
-#undef ULIMIT_BREAK_VALUE
-
 /* Define to 1 for Encore UMAX. */
 #undef UMAX
 
@@ -1397,6 +1401,9 @@ along with GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.  */
 /* Version number of package */
 #define VERSION "24.3.50"
 
+/* Define to 1 if unsetenv returns void instead of int. */
+#undef VOID_UNSETENV
+
 /* Define to l, ll, u, ul, ull, etc., as suitable for constants of type
    'wchar_t'. */
 #undef WCHAR_T_SUFFIX
diff --git a/nt/emacs.rc b/nt/emacs.rc
index 72aa47212ac..da4283b6fd1 100644
--- a/nt/emacs.rc
+++ b/nt/emacs.rc
@@ -1,5 +1,5 @@
-Emacs ICON   icons\emacs.ico
-32649 CURSOR icons\hand.cur
+Emacs ICON   icons/emacs.ico
+32649 CURSOR icons/hand.cur
 #ifdef WIN64
 1 24 "emacs-x64.manifest"
 #else
diff --git a/src/ChangeLog b/src/ChangeLog
index e7fc8179e07..9d9002ed77b 100644
--- a/src/ChangeLog
+++ b/src/ChangeLog
@@ -1,3 +1,163 @@
+2012-12-11  Dmitry Antipov  <dmantipov@yandex.ru>
+
+        * buffer.c (Fset_buffer_multibyte): Do not force redisplay
+        if changed buffer is not shown in a window.
+        * insdel.c (prepare_to_modify_buffer): Likewise.
+        * window.c (replace_buffer_in_windows_safely): Do nothing
+        if buffer is not shown in a window.
+        (Fforce_window_update): Likewise if string or buffer argument
+        is passed.
+
+2012-12-11  Eli Zaretskii  <eliz@gnu.org>
+
+        * inotify.c (Finotify_add_watch): Rename decoded_file_name to
+        encoded_file_name, which is what it is.
+
+2012-12-11  Dmitry Antipov  <dmantipov@yandex.ru>
+
+        Consistently use marker_position and marker_byte_position.
+        * fringe.c (Ffringe_bitmaps_at_pos):
+        * indent.c (Fvertical_motion):
+        * insdel.c (prepare_to_modify_buffer):
+        * keyboard.c (make_lispy_position):
+        * window.c (Fwindow_end, Fpos_visible_in_window_p, unshow_buffer)
+        (window_scroll_pixel_based, displayed_window_lines)
+        (Fset_window_configuration):
+        * xdisp.c (message_dolog, with_echo_area_buffer_unwind_data)
+        (mark_window_display_accurate_1, redisplay_window, decode_mode_spec):
+        Replace direct access to marker fields with calls
+        to marker_position and/or marker_byte_position.
+
+2012-12-11  Juanma Barranquero  <lekktu@gmail.com>
+
+        * makefile.w32-in (SIG2STR_H): New macro.
+        (SYSWAIT_H, $(BLD)/emacs.$(O), $(BLD)/process.$(O))
+        ($(BLD)/w32notify.$(O)): Update dependencies.
+
+2012-12-10  Daniel Colascione  <dancol@dancol.org>
+
+        * w32term.c, keyboard.c: Fix build break in cygw32 by omitting
+        Windows file notification functionality unless WINDOWSNT.
+
+        * w32gui.h (hprevinst, lpCmdLine, nCmdShow): Remove unused
+        declarations.
+
+        * w32fns.c (cache_system_info): Initialize the global hinst
+        variable here so various initialization calls DTRT.
+
+        * unexw32.c (hprevinst, lpCmdLine, nCmdShow): Remove unused
+        variables.
+        (hinst): Remove unneeded extern declaration.
+        (_start): Remove initialization of above variables; remove
+        initialization of hinst, as cache_system_info now does that.
+
+        * emacs.c (main): Call cache_system_info early in startup; we
+        previously weren't calling it in Cygwin builds.
+
+        * Makefile.in (ntsource, WINDRES, W32_RES, W#@_RES_LINK): Teach
+        the autoconf build system how to compile a Windows resource file
+        and link it to Emacs.
+
+2012-12-10  Dmitry Antipov  <dmantipov@yandex.ru>
+
+        Per-buffer window counters.
+        * buffer.h (struct buffer): New member window_count.
+        (buffer_window_count): New function.
+        * buffer.c (Fget_buffer_create, Fmake_indirect_buffer):
+        Initialize window_count.
+        (Fkill_buffer): Verify window_count for the buffer being killed.
+        (modify_overlay): Do not force redisplay if buffer is not shown
+        in any window.
+        (init_buffer_once): Initialize window_count for buffer_defaults
+        and buffer_local_symbols.
+        * window.h (buffer_shared): Remove declaration.
+        (wset_buffer): Convert from inline ...
+        * window.c (wset_buffer): ... to an ordinary function.
+        (adjust_window_count): New function.
+        (make_parent_window): Use it.
+        * xdisp.c (buffer_shared): Remove.
+        (redisplay_internal, redisplay_window): Adjust users.
+        (buffer_shared_and_changed): Use per-buffer window counter.
+
+2012-12-10  Eli Zaretskii  <eliz@gnu.org>
+
+        Support for filesystem notifications on MS-Windows.
+        * w32proc.c (sys_select): If drain_message_queue returns non-zero,
+        and this is a TTY frame, signal the caller that keyboard input is
+        available.
+
+        * w32xfns.c (drain_message_queue): Now returns an int: an
+        indication whether any WM_EMACS_FILENOTIFY messages were found in
+        the queue.
+
+        * w32inevt.c (handle_file_notifications): New function.
+        (w32_console_read_socket): Call it to process file notifications.
+
+        * w32console.c (initialize_w32_display): Record the main thread ID
+        in dwMainThreadId.
+
+        * deps.mk (inotify.o): New dependency list.
+
+        * Makefile.in (SOME_MACHINE_OBJECTS): Add w32notify.o.
+
+        * w32term.h (WM_EMACS_FILENOTIFY): New custom message.
+        (WM_EMACS_END): Bump value by 1.
+        (notification_buffer_in_use, file_notifications)
+        (notifications_size, notifications_desc): Declare.
+        (w32_get_watch_object, lispy_file_action, globals_of_w32notify):
+        Add prototypes.
+
+        * w32term.c (lispy_file_action, queue_notifications): New functions.
+        (syms_of_w32term) <Qadded, Qremoved, Qmodified, Qrenamed_from>
+        <Qrenamed_to>: New symbols.
+        (w32_read_socket): Handle the WM_EMACS_FILENOTIFY message.
+
+        * w32notify.c: New file, implements file event notifications for
+        MS-Windows.
+
+        * w32fns.c (w32_wnd_proc): Handle the WM_EMACS_FILENOTIFY message
+        by posting it to the w32_read_socket queue.
+
+        * termhooks.h (enum event_kind) [HAVE_NTGUI]: Support
+        FILE_NOTIFY_EVENT.
+
+        * makefile.w32-in (OBJ2): Add $(BLD)/w32notify.$(O).
+        (GLOBAL_SOURCES): Add w32notify.c
+        ($(BLD)/w32notify.$(O)): New set of dependencies.
+
+        * lisp.h (syms_of_w32notify) [WINDOWSNT]: Add prototype.
+
+        * keyboard.c (kbd_buffer_get_event) [WINDOWSNT]: Handle
+        FILE_NOTIFY_EVENT.
+        (syms_of_keyboard) [HAVE_NTGUI] <Qfile_notify>: New symbol.
+        (keys_of_keyboard) [WINDOWSNT]: Bind file-notify to
+        w32notify-handle-event by default.
+
+        * emacs.c (main) [WINDOWSNT]: Call globals_of_w32notify and
+        syms_of_w32notify.
+
+2012-12-10  Rüdiger Sonderfeld  <ruediger@c-plusplus.de>
+
+        Support for filesystem notifications on GNU/Linux via inotify.
+        * termhooks.h (enum event_kind) [HAVE_INOTIFY]: Add
+        FILE_NOTIFY_EVENT.
+
+        * lisp.h (syms_of_inotify) [HAVE_INOTIFY]: Add prototype.
+
+        * keyboard.c (Qfile_inotify) [HAVE_INOTIFY]: New variable.
+        (syms_of_keyboard): DEFSYM it.
+        (kbd_buffer_get_event) [HAVE_INOTIFY]: Generate FILE_NOTIFY_EVENT.
+        (make_lispy_event): Support FILE_NOTIFY_EVENT by generating
+        Qfile_inotify events.
+        (keys_of_keyboard) [HAVE_INOTIFY]: Bind file-inotify events in
+        special-event-map to inotify-handle-event.
+
+        * emacs.c (main) [HAVE_INOTIFY]: Call syms_of_inotify.
+
+        * Makefile.in (base_obj): Add inotify.o.
+
+        * inotify.c: New file.
+
 2012-12-10  Jan Djärv  <jan.h.d@swipnet.se>
 
         * nsterm.m (fd_handler:): FD_ZERO fds (Bug#13103).
diff --git a/src/Makefile.in b/src/Makefile.in
index 88e1fc544d0..fe3a15f193a 100644
--- a/src/Makefile.in
+++ b/src/Makefile.in
@@ -28,9 +28,11 @@ SHELL = /bin/sh
 # Here are the things that we expect ../configure to edit.
 # We use $(srcdir) explicitly in dependencies so as not to depend on VPATH.
 srcdir = @srcdir@
+ntsource = $(srcdir)/../nt
 abs_builddir = @abs_builddir@
 VPATH = $(srcdir)
 CC = @CC@
+WINDRES = @WINDRES@
 CFLAGS = @CFLAGS@
 CPPFLAGS = @CPPFLAGS@
 LDFLAGS = @LDFLAGS@
@@ -276,6 +278,13 @@ W32_OBJ=@W32_OBJ@
 ## --lwinspool if HAVE_W32, else empty.
 W32_LIBS=@W32_LIBS@
 
+## emacs.res if HAVE_W32
+W32_RES=@W32_RES@
+## If HAVE_W32, compiler arguments for including
+## the resource file in the binary.
+## XXX -Wl,-b -Wl,pe-i386 -Wl,emacs.res
+W32_RES_LINK=@W32_RES_LINK@
+
 ## Empty if !HAVE_X_WINDOWS
 ## xfont.o ftfont.o xftfont.o ftxfont.o if HAVE_XFT
 ## xfont.o ftfont.o ftxfont.o if HAVE_FREETYPE
@@ -339,7 +348,6 @@ ALL_OBJC_CFLAGS=$(ALL_CFLAGS) $(GNU_OBJC_CFLAGS)
         @$(MKDEPDIR)
         $(CC) -c $(CPPFLAGS) $(ALL_OBJC_CFLAGS) $<
 
-
 ## lastfile must follow all files whose initialized data areas should
 ## be dumped as pure by dump-emacs.
 base_obj = dispnew.o frame.o scroll.o xdisp.o menu.o $(XMENU_OBJ) window.o \
@@ -354,7 +362,7 @@ 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 \
+        doprnt.o intervals.o textprop.o composite.o xml.o inotify.o \
         xwidget.o \
         profiler.o \
         $(MSDOS_OBJ) $(MSDOS_X_OBJ) $(NS_OBJ) $(CYGWIN_OBJ) $(FONT_OBJ) \
@@ -370,7 +378,7 @@ SOME_MACHINE_OBJECTS = dosfns.o msdos.o \
   xterm.o xfns.o xmenu.o xselect.o xrdb.o xsmfns.o fringe.o image.o \
   fontset.o dbusbind.o cygw32.o \
   nsterm.o nsfns.o nsmenu.o nsselect.o nsimage.o nsfont.o \
-  w32.o w32console.o w32fns.o w32heap.o w32inevt.o \
+  w32.o w32console.o w32fns.o w32heap.o w32inevt.o w32notify.o \
   w32menu.o w32proc.o w32reg.o w32select.o w32term.o w32xfns.o \
   w16select.o widget.o xfont.o ftfont.o xftfont.o ftxfont.o gtkutil.o \
   xsettings.o xgselect.o termcap.o
@@ -476,9 +484,11 @@ $(obj) $(otherobj): globals.h
 $(lib)/libgnu.a: $(config_h)
         cd $(lib) && $(MAKE) libgnu.a
 
-temacs$(EXEEXT): $(START_FILES) stamp-oldxmenu $(obj) $(otherobj) $(lib)/libgnu.a
+temacs$(EXEEXT): $(START_FILES) stamp-oldxmenu $(obj) $(otherobj) \
+                 $(lib)/libgnu.a $(W32_RES)
         $(CC) $(LD_FIRSTFLAG) $(ALL_CFLAGS) $(TEMACS_LDFLAGS) $(TEMACS_LDFLAGS2) \
-          -o temacs $(START_FILES) $(obj) $(otherobj) $(lib)/libgnu.a $(LIBES)
+          -o temacs $(START_FILES) $(obj) $(otherobj) $(lib)/libgnu.a $(LIBES) \
+          $(W32_RES_LINK)
         test "$(CANNOT_DUMP)" = "yes" || \
           test "X$(PAXCTL)" = X || $(PAXCTL) -r temacs$(EXEEXT)
 
@@ -519,11 +529,14 @@ $(OLDXMENU): $(OLDXMENU_TARGET)
 
 doc.o: buildobj.h
 
+emacs.res: $(ntsource)/emacs.rc \
+           $(ntsource)/icons/emacs.ico \
+           $(ntsource)/emacs-x86.manifest
+        $(WINDRES) -O COFF -o $@ $(ntsource)/emacs.rc
 
 ns-app: emacs$(EXEEXT)
         cd ../nextstep && $(MAKE) $(MFLAGS) all
 
-
 .PHONY: mostlyclean clean bootstrap-clean distclean maintainer-clean
 .PHONY: versionclean extraclean frc
 
diff --git a/src/buffer.c b/src/buffer.c
index 6e2191dc22f..748422df73a 100644
--- a/src/buffer.c
+++ b/src/buffer.c
@@ -547,6 +547,8 @@ even if it is dead.  The return value is never nil.  */)
   b->base_buffer = NULL;
   /* No one shares the text with us now.  */
   b->indirections = 0;
+  /* No one shows us now.  */
+  b->window_count = 0;
 
   BUF_GAP_SIZE (b) = 20;
   block_input ();
@@ -794,6 +796,8 @@ CLONE nil means the indirect buffer's state is reset to default values.  */)
   b->indirections = -1;
   /* Notify base buffer that we share the text now.  */
   b->base_buffer->indirections++;
+  /* Always -1 for an indirect buffer.  */
+  b->window_count = -1;
 
   b->pt = b->base_buffer->pt;
   b->begv = b->base_buffer->begv;
@@ -1929,10 +1933,16 @@ cleaning up all windows currently displaying the buffer to be killed. */)
       eassert (b->indirections == -1);
       b->base_buffer->indirections--;
       eassert (b->base_buffer->indirections >= 0);
+      /* Make sure that we wasn't confused.  */
+      eassert (b->window_count == -1);
     }
   else
-    /* No one shares our buffer text, can free it.  */
-    free_buffer_text (b);
+    {
+      /* Make sure that no one shows us.  */
+      eassert (b->window_count == 0);
+      /* No one shares our buffer text, can free it.  */
+      free_buffer_text (b);
+    }
 
   if (b->newline_cache)
     {
@@ -2681,10 +2691,11 @@ current buffer is cleared.  */)
 
   UNGCPRO;
 
-  /* Changing the multibyteness of a buffer means that all windows
-     showing that buffer must be updated thoroughly.  */
   current_buffer->prevent_redisplay_optimizations_p = 1;
-  ++windows_or_buffers_changed;
+
+  /* If buffer is shown in a window, let redisplay consider other windows.  */
+  if (buffer_window_count (current_buffer))
+    ++windows_or_buffers_changed;
 
   /* Copy this buffer's new multibyte status
      into all of its indirect buffers.  */
@@ -3880,17 +3891,17 @@ modify_overlay (struct buffer *buf, ptrdiff_t start, ptrdiff_t end)
 
   BUF_COMPUTE_UNCHANGED (buf, start, end);
 
-  /* If this is a buffer not in the selected window,
-     we must do other windows.  */
-  if (buf != XBUFFER (XWINDOW (selected_window)->buffer))
-    windows_or_buffers_changed = 1;
-  /* If multiple windows show this buffer, we must do other windows.  */
-  else if (buffer_shared > 1)
-    windows_or_buffers_changed = 1;
-  /* If we modify an overlay at the end of the buffer, we cannot
-     be sure that window end is still valid.  */
-  else if (end >= ZV && start <= ZV)
-    windows_or_buffers_changed = 1;
+  /* If BUF is visible, consider updating the display if ...  */
+  if (buffer_window_count (buf) > 0)
+    {
+      /* ... it's visible in other window than selected,  */
+      if (buf != XBUFFER (XWINDOW (selected_window)->buffer))
+        windows_or_buffers_changed = 1;
+      /* ... or if we modify an overlay at the end of the buffer
+         and so we cannot be sure that window end is still valid.  */
+      else if (end >= ZV && start <= ZV)
+        windows_or_buffers_changed = 1;
+    }
 
   ++BUF_OVERLAY_MODIFF (buf);
 }
@@ -5125,6 +5136,9 @@ init_buffer_once (void)
   /* No one will share the text with these buffers, but let's play it safe.  */
   buffer_defaults.indirections = 0;
   buffer_local_symbols.indirections = 0;
+  /* Likewise no one will display them.  */
+  buffer_defaults.window_count = 0;
+  buffer_local_symbols.window_count = 0;
   set_buffer_intervals (&buffer_defaults, NULL);
   set_buffer_intervals (&buffer_local_symbols, NULL);
   /* This is not strictly necessary, but let's make them initialized.  */
diff --git a/src/buffer.h b/src/buffer.h
index 1129840bd47..d838d3767ef 100644
--- a/src/buffer.h
+++ b/src/buffer.h
@@ -770,11 +770,15 @@ struct buffer
      In an ordinary buffer, it is 0.  */
   struct buffer *base_buffer;
 
-  /* In an indirect buffer, this is -1. In an ordinary buffer,
+  /* In an indirect buffer, this is -1.  In an ordinary buffer,
      it's the number of indirect buffers that share our text;
      zero means that we're the only owner of this text.  */
   int indirections;
 
+  /* Number of windows showing this buffer.  Always -1 for
+     an indirect buffer since it counts as its base buffer.  */
+  int window_count;
+
   /* A non-zero value in slot IDX means that per-buffer variable
      with index IDX has a local value in this buffer.  The index IDX
      for a buffer-local variable is stored in that variable's slot
@@ -1173,7 +1177,18 @@ BUF_FETCH_MULTIBYTE_CHAR (struct buffer *buf, ptrdiff_t pos)
        + pos + BUF_BEG_ADDR (buf) - BEG_BYTE);
   return STRING_CHAR (p);
 }
-
+
+/* Return number of windows showing B.  */
+
+BUFFER_INLINE int
+buffer_window_count (struct buffer *b)
+{
+  if (b->base_buffer)
+    b = b->base_buffer;
+  eassert (b->window_count >= 0);
+  return b->window_count;
+}
+
 /* Overlays */
 
 /* Return the marker that stands for where OV starts in the buffer.  */
diff --git a/src/deps.mk b/src/deps.mk
index c7316a24dad..beca5f7c6bc 100644
--- a/src/deps.mk
+++ b/src/deps.mk
@@ -128,6 +128,7 @@ image.o: image.c frame.h window.h dispextern.h blockinput.h atimer.h \
 indent.o: indent.c frame.h window.h indent.h buffer.h lisp.h $(config_h) \
    termchar.h termopts.h disptab.h region-cache.h character.h category.h \
    keyboard.h systime.h coding.h $(INTERVALS_H) globals.h
+inotify.o: inotify.c lisp.h coding.h process.h keyboard.h frame.h termhooks.h
 insdel.o: insdel.c window.h buffer.h $(INTERVALS_H) blockinput.h character.h \
    atimer.h systime.h region-cache.h lisp.h globals.h $(config_h)
 keyboard.o: keyboard.c termchar.h termhooks.h termopts.h buffer.h character.h \
diff --git a/src/emacs.c b/src/emacs.c
index bd6654aa8cf..4d8e0be7470 100644
--- a/src/emacs.c
+++ b/src/emacs.c
@@ -41,6 +41,7 @@ along with GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.  */
 #if defined WINDOWSNT || defined HAVE_NTGUI
 #include "w32select.h"
 #include "w32font.h"
+#include "w32common.h"
 #endif
 
 #if defined HAVE_NTGUI && defined CYGWIN
@@ -736,6 +737,13 @@ main (int argc, char **argv)
     }
 #endif
 
+#if defined WINDOWSNT || defined HAVE_NTGUI
+  /* Set global variables used to detect Windows version.  Do this as
+     early as possible.  (unexw32.c calls this function as well, but
+     the additional call here is harmless.) */
+  cache_system_info ();
+#endif
+
 #ifdef RUN_TIME_REMAP
   if (initialized)
     run_time_remap (argv[0]);
@@ -1290,6 +1298,7 @@ Using an Emacs configured with --with-x-toolkit=lucid does not have this problem
 
 #ifdef WINDOWSNT
   globals_of_w32 ();
+  globals_of_w32notify ();
   /* Initialize environment from registry settings.  */
   init_environment (argv);
   init_ntproc (dumping); /* must precede init_editfns.  */
@@ -1448,12 +1457,17 @@ Using an Emacs configured with --with-x-toolkit=lucid does not have this problem
       syms_of_gnutls ();
 #endif
 
+#ifdef HAVE_INOTIFY
+      syms_of_inotify ();
+#endif /* HAVE_INOTIFY */
+
 #ifdef HAVE_DBUS
       syms_of_dbusbind ();
 #endif /* HAVE_DBUS */
 
 #ifdef WINDOWSNT
       syms_of_ntterm ();
+      syms_of_w32notify ();
 #endif /* WINDOWSNT */
 
       syms_of_profiler ();
diff --git a/src/fringe.c b/src/fringe.c
index a126292e1ff..ce31fd01763 100644
--- a/src/fringe.c
+++ b/src/fringe.c
@@ -1744,7 +1744,7 @@ Return nil if POS is not visible in WINDOW.  */)
   else if (w == XWINDOW (selected_window))
     textpos = PT;
   else
-    textpos = XMARKER (w->pointm)->charpos;
+    textpos = marker_position (w->pointm);
 
   row = MATRIX_FIRST_TEXT_ROW (w->current_matrix);
   row = row_containing_pos (w, textpos, row, NULL, 0);
diff --git a/src/indent.c b/src/indent.c
index 327526eae2d..3dbf372cf17 100644
--- a/src/indent.c
+++ b/src/indent.c
@@ -1991,8 +1991,8 @@ whether or not it is currently displayed in some window.  */)
     {
       /* Set the window's buffer temporarily to the current buffer.  */
       old_buffer = w->buffer;
-      old_charpos = XMARKER (w->pointm)->charpos;
-      old_bytepos = XMARKER (w->pointm)->bytepos;
+      old_charpos = marker_position (w->pointm);
+      old_bytepos = marker_byte_position (w->pointm);
       wset_buffer (w, Fcurrent_buffer ());
       set_marker_both (w->pointm, w->buffer,
                        BUF_PT (current_buffer), BUF_PT_BYTE (current_buffer));
diff --git a/src/inotify.c b/src/inotify.c
new file mode 100644
index 00000000000..17104c89064
--- /dev/null
+++ b/src/inotify.c
@@ -0,0 +1,438 @@
+/* Inotify support for Emacs
+
+Copyright (C) 2012
+  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_INOTIFY
+
+#include "lisp.h"
+#include "coding.h"
+#include "process.h"
+#include "keyboard.h"
+#include "character.h"
+#include "frame.h" /* Required for termhooks.h.  */
+#include "termhooks.h"
+
+static Lisp_Object Qaccess;        /* IN_ACCESS */
+static Lisp_Object Qattrib;        /* IN_ATTRIB */
+static Lisp_Object Qclose_write;   /* IN_CLOSE_WRITE */
+static Lisp_Object Qclose_nowrite; /* IN_CLOSE_NOWRITE */
+static Lisp_Object Qcreate;        /* IN_CREATE */
+static Lisp_Object Qdelete;        /* IN_DELETE */
+static Lisp_Object Qdelete_self;   /* IN_DELETE_SELF */
+static Lisp_Object Qmodify;        /* IN_MODIFY */
+static Lisp_Object Qmove_self;     /* IN_MOVE_SELF */
+static Lisp_Object Qmoved_from;    /* IN_MOVED_FROM */
+static Lisp_Object Qmoved_to;      /* IN_MOVED_TO */
+static Lisp_Object Qopen;          /* IN_OPEN */
+
+static Lisp_Object Qall_events;    /* IN_ALL_EVENTS */
+static Lisp_Object Qmove;          /* IN_MOVE */
+static Lisp_Object Qclose;         /* IN_CLOSE */
+
+static Lisp_Object Qdont_follow;   /* IN_DONT_FOLLOW */
+static Lisp_Object Qexcl_unlink;   /* IN_EXCL_UNLINK */
+static Lisp_Object Qmask_add;      /* IN_MASK_ADD */
+static Lisp_Object Qoneshot;       /* IN_ONESHOT */
+static Lisp_Object Qonlydir;       /* IN_ONLYDIR */
+
+static Lisp_Object Qignored;       /* IN_IGNORED */
+static Lisp_Object Qisdir;         /* IN_ISDIR */
+static Lisp_Object Qq_overflow;    /* IN_Q_OVERFLOW */
+static Lisp_Object Qunmount;       /* IN_UNMOUNT */
+
+#include <sys/inotify.h>
+#include <sys/ioctl.h>
+
+/* Ignore bits that might be undefined on old GNU/Linux systems.  */
+#ifndef IN_EXCL_UNLINK
+# define IN_EXCL_UNLINK 0
+#endif
+#ifndef IN_DONT_FOLLOW
+# define IN_DONT_FOLLOW 0
+#endif
+#ifndef IN_ONLYDIR
+# define IN_ONLYDIR 0
+#endif
+
+enum { uninitialized = -100 };
+/* File handle for inotify.  */
+static int inotifyfd = uninitialized;
+
+/* Assoc list of files being watched.
+   Format:
+   (watch-descriptor . callback)
+ */
+static Lisp_Object watch_list;
+
+static Lisp_Object
+make_watch_descriptor (int wd)
+{
+  /* TODO replace this with a Misc Object! */
+  return make_number (wd);
+}
+
+static Lisp_Object
+mask_to_aspects (uint32_t mask) {
+  Lisp_Object aspects = Qnil;
+  if (mask & IN_ACCESS)
+    aspects = Fcons (Qaccess, aspects);
+  if (mask & IN_ATTRIB)
+    aspects = Fcons (Qattrib, aspects);
+  if (mask & IN_CLOSE_WRITE)
+    aspects = Fcons (Qclose_write, aspects);
+  if (mask & IN_CLOSE_NOWRITE)
+    aspects = Fcons (Qclose_nowrite, aspects);
+  if (mask & IN_CREATE)
+    aspects = Fcons (Qcreate, aspects);
+  if (mask & IN_DELETE)
+    aspects = Fcons (Qdelete, aspects);
+  if (mask & IN_DELETE_SELF)
+    aspects = Fcons (Qdelete_self, aspects);
+  if (mask & IN_MODIFY)
+    aspects = Fcons (Qmodify, aspects);
+  if (mask & IN_MOVE_SELF)
+    aspects = Fcons (Qmove_self, aspects);
+  if (mask & IN_MOVED_FROM)
+    aspects = Fcons (Qmoved_from, aspects);
+  if (mask & IN_MOVED_TO)
+    aspects = Fcons (Qmoved_to, aspects);
+  if (mask & IN_OPEN)
+    aspects = Fcons (Qopen,  aspects);
+  if (mask & IN_IGNORED)
+    aspects = Fcons (Qignored, aspects);
+  if (mask & IN_ISDIR)
+    aspects = Fcons (Qisdir, aspects);
+  if (mask & IN_Q_OVERFLOW)
+    aspects = Fcons (Qq_overflow, aspects);
+  if (mask & IN_UNMOUNT)
+    aspects = Fcons (Qunmount, aspects);
+  return aspects;
+}
+
+static Lisp_Object
+inotifyevent_to_event (Lisp_Object watch_object, struct inotify_event const *ev)
+{
+  Lisp_Object name = Qnil;
+  if (ev->len > 0)
+    {
+      size_t const len = strlen (ev->name);
+      name = make_unibyte_string (ev->name, min (len, ev->len));
+      name = DECODE_FILE (name);
+    }
+
+  return list2 (list4 (make_watch_descriptor (ev->wd),
+                       mask_to_aspects (ev->mask),
+                       make_number (ev->cookie),
+                       name),
+                XCDR (watch_object));
+}
+
+/* This callback is called when the FD is available for read.  The inotify
+   events are read from FD and converted into input_events.  */
+static void
+inotify_callback (int fd, void *_)
+{
+  struct input_event event;
+  Lisp_Object watch_object;
+  int to_read;
+  char *buffer;
+  ssize_t n;
+  size_t i;
+
+  to_read = 0;
+  if (ioctl (fd, FIONREAD, &to_read) == -1)
+    report_file_error ("Error while trying to retrieve file system events",
+                       Qnil);
+  buffer = xmalloc (to_read);
+  n = read (fd, buffer, to_read);
+  if (n < 0)
+    {
+      xfree (buffer);
+      report_file_error ("Error while trying to read file system events",
+                         Qnil);
+    }
+
+  EVENT_INIT (event);
+  event.kind = FILE_NOTIFY_EVENT;
+  event.arg = Qnil;
+
+  i = 0;
+  while (i < (size_t)n)
+    {
+      struct inotify_event *ev = (struct inotify_event*)&buffer[i];
+
+      watch_object = Fassoc (make_watch_descriptor (ev->wd), watch_list);
+      if (!NILP (watch_object))
+        {
+          event.arg = inotifyevent_to_event (watch_object, ev);
+
+          /* If event was removed automatically: Drop it from watch list.  */
+          if (ev->mask & IN_IGNORED)
+            watch_list = Fdelete (watch_object, watch_list);
+        }
+
+      i += sizeof (*ev) + ev->len;
+    }
+
+  if (!NILP (event.arg))
+    kbd_buffer_store_event (&event);
+
+  xfree (buffer);
+}
+
+static uint32_t
+symbol_to_inotifymask (Lisp_Object symb)
+{
+  if (EQ (symb, Qaccess))
+    return IN_ACCESS;
+  else if (EQ (symb, Qattrib))
+    return IN_ATTRIB;
+  else if (EQ (symb, Qclose_write))
+    return IN_CLOSE_WRITE;
+  else if (EQ (symb, Qclose_nowrite))
+    return IN_CLOSE_NOWRITE;
+  else if (EQ (symb, Qcreate))
+    return IN_CREATE;
+  else if (EQ (symb, Qdelete))
+    return IN_DELETE;
+  else if (EQ (symb, Qdelete_self))
+    return IN_DELETE_SELF;
+  else if (EQ (symb, Qmodify))
+    return IN_MODIFY;
+  else if (EQ (symb, Qmove_self))
+    return IN_MOVE_SELF;
+  else if (EQ (symb, Qmoved_from))
+    return IN_MOVED_FROM;
+  else if (EQ (symb, Qmoved_to))
+    return IN_MOVED_TO;
+  else if (EQ (symb, Qopen))
+    return IN_OPEN;
+  else if (EQ (symb, Qmove))
+    return IN_MOVE;
+  else if (EQ (symb, Qclose))
+    return IN_CLOSE;
+
+  else if (EQ (symb, Qdont_follow))
+    return IN_DONT_FOLLOW;
+  else if (EQ (symb, Qexcl_unlink))
+    return IN_EXCL_UNLINK;
+  else if (EQ (symb, Qmask_add))
+    return IN_MASK_ADD;
+  else if (EQ (symb, Qoneshot))
+    return IN_ONESHOT;
+  else if (EQ (symb, Qonlydir))
+    return IN_ONLYDIR;
+
+  else if (EQ (symb, Qt) || EQ (symb, Qall_events))
+    return IN_ALL_EVENTS;
+  else
+    signal_error ("Unknown aspect", symb);
+}
+
+static uint32_t
+aspect_to_inotifymask (Lisp_Object aspect)
+{
+  if (CONSP (aspect))
+    {
+      Lisp_Object x = aspect;
+      uint32_t mask = 0;
+      while (CONSP (x))
+        {
+          mask |= symbol_to_inotifymask (XCAR (x));
+          x = XCDR (x);
+        }
+      return mask;
+    }
+  else
+    return symbol_to_inotifymask (aspect);
+}
+
+DEFUN ("inotify-add-watch", Finotify_add_watch, Sinotify_add_watch, 3, 3, 0,
+       doc: /* Add a watch for FILE-NAME to inotify.
+
+A WATCH-DESCRIPTOR is returned on success.  ASPECT might be one of the following
+symbols or a list of those symbols:
+
+access
+attrib
+close-write
+close-nowrite
+create
+delete
+delete-self
+modify
+move-self
+moved-from
+moved-to
+open
+
+all-events or t
+move
+close
+
+The following symbols can also be added to a list of aspects
+
+dont-follow
+excl-unlink
+mask-add
+oneshot
+onlydir
+
+Watching a directory is not recursive.  CALLBACK gets called in case of an
+event.  It gets passed a single argument EVENT which contains an event structure
+of the format
+
+(WATCH-DESCRIPTOR ASPECTS COOKIE NAME)
+
+WATCH-DESCRIPTOR is the same object that was returned by this function.  It can
+be tested for equality using `equal'.  ASPECTS describes the event.  It is a
+list of ASPECT symbols described above and can also contain one of the following
+symbols
+
+ignored
+isdir
+q-overflow
+unmount
+
+COOKIE is an object that can be compared using `equal' to identify two matching
+renames (moved-from and moved-to).
+
+If a directory is watched then NAME is the name of file that caused the event.
+
+See inotify(7) and inotify_add_watch(2) for further information.  The inotify fd
+is managed internally and there is no corresponding inotify_init.  Use
+`inotify-rm-watch' to remove a watch.
+             */)
+     (Lisp_Object file_name, Lisp_Object aspect, Lisp_Object callback)
+{
+  uint32_t mask;
+  Lisp_Object watch_object;
+  Lisp_Object encoded_file_name;
+  Lisp_Object watch_descriptor;
+  int watchdesc = -1;
+
+  CHECK_STRING (file_name);
+
+  if (inotifyfd == uninitialized)
+    {
+      inotifyfd = inotify_init1 (IN_NONBLOCK|IN_CLOEXEC);
+      if (inotifyfd == -1)
+        {
+          inotifyfd = uninitialized;
+          report_file_error ("File watching feature (inotify) is not available",
+                             Qnil);
+        }
+      watch_list = Qnil;
+      add_read_fd (inotifyfd, &inotify_callback, NULL);
+    }
+
+  mask = aspect_to_inotifymask (aspect);
+  encoded_file_name = ENCODE_FILE (file_name);
+  watchdesc = inotify_add_watch (inotifyfd, SSDATA (encoded_file_name), mask);
+  if (watchdesc == -1)
+    report_file_error ("Could not add watch for file", Fcons (file_name, Qnil));
+
+  watch_descriptor = make_watch_descriptor (watchdesc);
+
+  /* Delete existing watch object. */
+  watch_object = Fassoc (watch_descriptor, watch_list);
+  if (!NILP (watch_object))
+      watch_list = Fdelete (watch_object, watch_list);
+
+  /* Store watch object in watch list. */
+  watch_object = Fcons (watch_descriptor, callback);
+  watch_list = Fcons (watch_object, watch_list);
+
+  return watch_descriptor;
+}
+
+DEFUN ("inotify-rm-watch", Finotify_rm_watch, Sinotify_rm_watch, 1, 1, 0,
+       doc: /* Remove an existing WATCH-DESCRIPTOR.
+
+WATCH-DESCRIPTOR should be an object returned by `inotify-add-watch'.
+
+See inotify_rm_watch(2) for more information.
+             */)
+     (Lisp_Object watch_descriptor)
+{
+  Lisp_Object watch_object;
+  int wd = XINT (watch_descriptor);
+
+  if (inotify_rm_watch (inotifyfd, wd) == -1)
+    report_file_error ("Could not rm watch", Fcons (watch_descriptor,
+                                                    Qnil));
+
+  /* Remove watch descriptor from watch list. */
+  watch_object = Fassoc (watch_descriptor, watch_list);
+  if (!NILP (watch_object))
+    watch_list = Fdelete (watch_object, watch_list);
+
+  /* Cleanup if no more files are watched. */
+  if (NILP (watch_list))
+    {
+      close (inotifyfd);
+      delete_read_fd (inotifyfd);
+      inotifyfd = uninitialized;
+    }
+
+  return Qt;
+}
+
+void
+syms_of_inotify (void)
+{
+  DEFSYM (Qaccess, "access");
+  DEFSYM (Qattrib, "attrib");
+  DEFSYM (Qclose_write, "close-write");
+  DEFSYM (Qclose_nowrite, "close-nowrite");
+  DEFSYM (Qcreate, "create");
+  DEFSYM (Qdelete, "delete");
+  DEFSYM (Qdelete_self, "delete-self");
+  DEFSYM (Qmodify, "modify");
+  DEFSYM (Qmove_self, "move-self");
+  DEFSYM (Qmoved_from, "moved-from");
+  DEFSYM (Qmoved_to, "moved-to");
+  DEFSYM (Qopen, "open");
+
+  DEFSYM (Qall_events, "all-events");
+  DEFSYM (Qmove, "move");
+  DEFSYM (Qclose, "close");
+
+  DEFSYM (Qdont_follow, "dont-follow");
+  DEFSYM (Qexcl_unlink, "excl-unlink");
+  DEFSYM (Qmask_add, "mask-add");
+  DEFSYM (Qoneshot, "oneshot");
+  DEFSYM (Qonlydir, "onlydir");
+
+  DEFSYM (Qignored, "ignored");
+  DEFSYM (Qisdir, "isdir");
+  DEFSYM (Qq_overflow, "q-overflow");
+  DEFSYM (Qunmount, "unmount");
+
+  defsubr (&Sinotify_add_watch);
+  defsubr (&Sinotify_rm_watch);
+
+  staticpro (&watch_list);
+
+  Fprovide (intern_c_string ("inotify"), Qnil);
+}
+
+#endif /* HAVE_INOTIFY */
diff --git a/src/insdel.c b/src/insdel.c
index 892ca3d5216..74e938c4b8c 100644
--- a/src/insdel.c
+++ b/src/insdel.c
@@ -1800,9 +1800,10 @@ prepare_to_modify_buffer (ptrdiff_t start, ptrdiff_t end,
   if (!NILP (BVAR (current_buffer, read_only)))
     Fbarf_if_buffer_read_only ();
 
-  /* Let redisplay consider other windows than selected_window
-     if modifying another buffer.  */
-  if (XBUFFER (XWINDOW (selected_window)->buffer) != current_buffer)
+  /* If we're modifying the buffer other than shown in a selected window,
+     let redisplay consider other windows if this buffer is visible.  */
+  if (XBUFFER (XWINDOW (selected_window)->buffer) != current_buffer
+      && buffer_window_count (current_buffer))
     ++windows_or_buffers_changed;
 
   if (buffer_intervals (current_buffer))
@@ -1854,7 +1855,7 @@ prepare_to_modify_buffer (ptrdiff_t start, ptrdiff_t end,
           : (!NILP (Vselect_active_regions)
              && !NILP (Vtransient_mark_mode))))
     {
-      ptrdiff_t b = XMARKER (BVAR (current_buffer, mark))->charpos;
+      ptrdiff_t b = marker_position (BVAR (current_buffer, mark));
       ptrdiff_t e = PT;
       if (b < e)
         Vsaved_region_selection = make_buffer_string (b, e, 0);
diff --git a/src/keyboard.c b/src/keyboard.c
index 9b5e0c5865d..313c57fbe51 100644
--- a/src/keyboard.c
+++ b/src/keyboard.c
@@ -313,6 +313,9 @@ 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;
@@ -322,6 +325,9 @@ static Lisp_Object Qdbus_event;
 #ifdef HAVE_XWIDGETS
 Lisp_Object Qxwidget_event;
 #endif
+#ifdef HAVE_INOTIFY
+static Lisp_Object Qfile_inotify;
+#endif /* HAVE_INOTIFY */
 static Lisp_Object Qconfig_changed_event;
 
 /* Lisp_Object Qmouse_movement; - also an event header */
@@ -3907,6 +3913,18 @@ kbd_buffer_get_event (KBOARD **kbp,
           kbd_fetch_ptr = event + 1;
         }
 #endif
+#ifdef WINDOWSNT
+      else if (event->kind == FILE_NOTIFY_EVENT)
+        {
+          /* Make an event (file-notify (DESCRIPTOR ACTION FILE) CALLBACK).  */
+          obj = Fcons (Qfile_w32notify,
+                       list2 (list3 (make_number (event->code),
+                                     XCAR (event->arg),
+                                     XCDR (event->arg)),
+                              event->frame_or_window));
+          kbd_fetch_ptr = event + 1;
+        }
+#endif
       else if (event->kind == SAVE_SESSION_EVENT)
         {
           obj = Fcons (Qsave_session, Fcons (event->arg, Qnil));
@@ -3970,6 +3988,12 @@ kbd_buffer_get_event (KBOARD **kbp,
           obj = make_lispy_event (event);
           kbd_fetch_ptr = event + 1;
         }
+#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)
         {
@@ -5123,7 +5147,7 @@ make_lispy_position (struct frame *f, Lisp_Object x, Lisp_Object y,
             string_info = Fcons (string, make_number (charpos));
           textpos = (w == XWINDOW (selected_window)
                      && current_buffer == XBUFFER (w->buffer))
-            ? PT : XMARKER (w->pointm)->charpos;
+            ? PT : marker_position (w->pointm);
 
           xret = wx;
           yret = wy;
@@ -5883,13 +5907,23 @@ make_lispy_event (struct input_event *event)
         return Fcons (Qdbus_event, event->arg);
       }
 #endif /* HAVE_DBUS */
+
 #ifdef HAVE_XWIDGETS
     case XWIDGET_EVENT:
       {
         printf("cool, an xwidget event arrived in make_lispy_event!\n");
         return  Fcons (Qxwidget_event,event->arg);
       }
-#endif
+#endif /* HAVE_XWIDGETS */
+
+
+#ifdef HAVE_INOTIFY
+    case FILE_NOTIFY_EVENT:
+      {
+        return Fcons (Qfile_inotify, event->arg);
+      }
+#endif /* HAVE_INOTIFY */
+
     case CONFIG_CHANGED_EVENT:
         return Fcons (Qconfig_changed_event,
                       Fcons (event->arg,
@@ -11349,6 +11383,10 @@ 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
@@ -11356,7 +11394,11 @@ syms_of_keyboard (void)
 #ifdef HAVE_XWIDGETS
   Qxwidget_event = intern ("xwidget-event");
   staticpro (&Qxwidget_event);
-#endif
+#endif /* HAVE_XWIDGETS */
+#ifdef HAVE_INOTIFY
+  DEFSYM (Qfile_inotify, "file-inotify");
+#endif /* HAVE_INOTIFY */
+
   DEFSYM (QCenable, ":enable");
   DEFSYM (QCvisible, ":visible");
   DEFSYM (QChelp, ":help");
@@ -12113,11 +12155,20 @@ keys_of_keyboard (void)
                             "dbus-handle-event");
 #endif
 
+#ifdef HAVE_INOTIFY
+  /* Define a special event which is raised for inotify callback
+     functions.  */
+  initial_define_lispy_key (Vspecial_event_map, "file-inotify",
+                            "inotify-handle-event");
+#endif /* HAVE_INOTIFY */
+
   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 269022f5dfd..9422ae740c9 100644
--- a/src/lisp.h
+++ b/src/lisp.h
@@ -3521,6 +3521,16 @@ extern void syms_of_fontset (void);
 extern Lisp_Object Qfont_param;
 #endif
 
+#ifdef WINDOWSNT
+/* Defined on w32notify.c.  */
+extern void syms_of_w32notify (void);
+#endif
+
+/* Defined in inotify.c */
+#ifdef HAVE_INOTIFY
+extern void syms_of_inotify (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/makefile.w32-in b/src/makefile.w32-in
index a296f6eb393..facf79cf849 100644
--- a/src/makefile.w32-in
+++ b/src/makefile.w32-in
@@ -134,6 +134,7 @@ OBJ2 =  $(BLD)/sysdep.$(O)		\
         $(BLD)/w32menu.$(O)             \
         $(BLD)/w32reg.$(O)              \
         $(BLD)/w32font.$(O)             \
+        $(BLD)/w32notify.$(O)           \
         $(BLD)/w32uniscribe.$(O)
 
 LIBS =  $(TLIB0)        \
@@ -209,7 +210,7 @@ GLOBAL_SOURCES =   dosfns.c msdos.c \
         fontset.c menu.c dbusbind.c \
         w32.c w32console.c w32fns.c w32heap.c w32inevt.c cygw32.c \
         w32menu.c w32proc.c w32reg.c w32select.c w32term.c w32xfns.c \
-        font.c w32font.c w32uniscribe.c \
+        font.c w32font.c w32uniscribe.c w32notify.c \
         dispnew.c frame.c scroll.c xdisp.c window.c bidi.c \
         charset.c coding.c category.c ccl.c character.c chartab.c \
         cm.c term.c terminal.c xfaces.c \
@@ -461,6 +462,8 @@ U64_H          = $(GNU_LIB)/u64.h \
                  $(NT_INC)/stdint.h
 SHA512_H       = $(GNU_LIB)/sha512.h \
                  $(U64_H)
+SIG2STR_H      = $(GNU_LIB)/sig2str.h \
+                 $(GNU_LIB)/intprops.h
 SOCKET_H       = $(NT_INC)/sys/socket.h \
                  $(SRC)/w32.h
 STAT_TIME_H    = $(GNU_LIB)/stat-time.h \
@@ -471,6 +474,7 @@ SYSTTY_H       = $(SRC)/systty.h \
                  $(NT_INC)/sys/ioctl.h \
                  $(NT_INC)/unistd.h
 SYSWAIT_H      = $(SRC)/syswait.h \
+                 $(NT_INC)/stdbool.h \
                  $(NT_INC)/sys/wait.h
 TERMHOOKS_H    = $(SRC)/termhooks.h \
                  $(SYSTIME_H)
@@ -799,6 +803,7 @@ $(BLD)/emacs.$(O) : \
         $(SRC)/keymap.h \
         $(SRC)/unexec.h \
         $(SRC)/w32.h \
+        $(SRC)/w32common.h \
         $(SRC)/w32heap.h \
         $(SRC)/w32select.h \
         $(NT_INC)/sys/file.h \
@@ -1287,11 +1292,13 @@ $(BLD)/process.$(O) : \
         $(CHARACTER_H) \
         $(CODING_H) \
         $(CONFIG_H) \
+        $(C_CTYPE_H) \
         $(DISPEXTERN_H) \
         $(FRAME_H) \
         $(KEYBOARD_H) \
         $(LISP_H) \
         $(PROCESS_H) \
+        $(SIG2STR_H) \
         $(SOCKET_H) \
         $(SYSSIGNAL_H) \
         $(SYSTIME_H) \
@@ -1693,6 +1700,18 @@ $(BLD)/w32uniscribe.$(O) : \
         $(W32FONT_H) \
         $(W32TERM_H)
 
+$(BLD)/w32notify.$(O) : \
+        $(SRC)/w32notify.c \
+        $(SRC)/w32.h \
+        $(SRC)/w32common.h \
+        $(CODING_H) \
+        $(CONFIG_H) \
+        $(FRAME_H) \
+        $(KEYBOARD_H) \
+        $(LISP_H) \
+        $(TERMHOOKS_H) \
+        $(W32TERM_H)
+
 # Each object file depends on stamp_BLD, because in parallel builds we must
 # make sure $(BLD) exists before starting compilations.
 #
diff --git a/src/termhooks.h b/src/termhooks.h
index d4b472cfb24..79af2f91feb 100644
--- a/src/termhooks.h
+++ b/src/termhooks.h
@@ -213,7 +213,12 @@ enum event_kind
 #ifdef HAVE_XWIDGETS
   /* events generated by xwidgets*/
    , XWIDGET_EVENT
+
+#if defined (HAVE_INOTIFY) || defined (HAVE_NTGUI)
+  /* File or directory was changed.  */
+  , FILE_NOTIFY_EVENT
 #endif
+
 };
 
 /* If a struct input_event has a kind which is SELECTION_REQUEST_EVENT
diff --git a/src/unexw32.c b/src/unexw32.c
index 1e591a78b73..ee1deb5f92e 100644
--- a/src/unexw32.c
+++ b/src/unexw32.c
@@ -85,13 +85,6 @@ DWORD_PTR  extra_bss_size_static = 0;
 
 PIMAGE_SECTION_HEADER heap_section;
 
-#ifdef HAVE_NTGUI
-extern HINSTANCE hinst;
-HINSTANCE hprevinst = NULL;
-LPSTR lpCmdLine = "";
-int nCmdShow = 0;
-#endif /* HAVE_NTGUI */
-
 /* Startup code for running on NT.  When we are running as the dumped
    version, we need to bootstrap our heap and .bss section into our
    address space before we can actually hand off control to the startup
@@ -121,15 +114,6 @@ _start (void)
   /* Prevent Emacs from being locked up (eg. in batch mode) when
      accessing devices that aren't mounted (eg. removable media drives).  */
   SetErrorMode (SEM_FAILCRITICALERRORS);
-
-  /* Invoke the NT CRT startup routine now that our housecleaning
-     is finished.  */
-#ifdef HAVE_NTGUI
-  /* determine WinMain args like crt0.c does */
-  hinst = GetModuleHandle (NULL);
-  lpCmdLine = GetCommandLine ();
-  nCmdShow = SW_SHOWDEFAULT;
-#endif
   mainCRTStartup ();
 }
 
diff --git a/src/w32console.c b/src/w32console.c
index f0574689bf1..f201ff190c2 100644
--- a/src/w32console.c
+++ b/src/w32console.c
@@ -746,6 +746,9 @@ initialize_w32_display (struct terminal *term)
   else
     w32_console_unicode_input = 0;
 
+  /* This is needed by w32notify.c:send_notifications.  */
+  dwMainThreadId = GetCurrentThreadId ();
+
   /* Setup w32_display_info structure for this frame. */
 
   w32_initialize_display_info (build_string ("Console"));
diff --git a/src/w32fns.c b/src/w32fns.c
index 1b8483479a1..f69fbe05a6d 100644
--- a/src/w32fns.c
+++ b/src/w32fns.c
@@ -1821,7 +1821,6 @@ static LRESULT CALLBACK w32_wnd_proc (HWND, UINT, WPARAM, LPARAM);
 static BOOL
 w32_init_class (HINSTANCE hinst)
 {
-
   if (w32_unicode_gui)
     {
       WNDCLASSW  uwc;
@@ -3957,6 +3956,9 @@ w32_wnd_proc (HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam)
 
         return retval;
       }
+    case WM_EMACS_FILENOTIFY:
+      my_post_msg (&wmsg, hwnd, msg, wParam, lParam);
+      return 1;
 
     default:
       /* Check for messages registered at runtime. */
@@ -7024,6 +7026,9 @@ cache_system_info (void)
       DWORD data;
     } version;
 
+  /* Cache the module handle of Emacs itself.  */
+  hinst = GetModuleHandle (NULL);
+
   /* Cache the version of the operating system.  */
   version.data = GetVersion ();
   w32_major_version = version.info.major;
diff --git a/src/w32gui.h b/src/w32gui.h
index 0da8de97f23..fe2bb2334b5 100644
--- a/src/w32gui.h
+++ b/src/w32gui.h
@@ -79,9 +79,6 @@ typedef struct _XImage
 #define FACE_DEFAULT (~0)
 
 extern HINSTANCE hinst;
-extern HINSTANCE hprevinst;
-extern LPSTR lpCmdLine;
-extern int nCmdShow;
 
 /* Bit Gravity */
 
diff --git a/src/w32inevt.c b/src/w32inevt.c
index 899a6fb89bf..2cbf31efda3 100644
--- a/src/w32inevt.c
+++ b/src/w32inevt.c
@@ -576,6 +576,74 @@ maybe_generate_resize_event (void)
                      0, 0, 0);
 }
 
+static int
+handle_file_notifications (struct input_event *hold_quit)
+{
+  BYTE *p = file_notifications;
+  FILE_NOTIFY_INFORMATION *fni = (PFILE_NOTIFY_INFORMATION)p;
+  const DWORD min_size
+    = offsetof (FILE_NOTIFY_INFORMATION, FileName) + sizeof(wchar_t);
+  struct input_event inev;
+  int nevents = 0;
+
+  /* We cannot process notification before Emacs is fully initialized,
+     since we need the UTF-16LE coding-system to be set up.  */
+  if (!initialized)
+    {
+      notification_buffer_in_use = 0;
+      return nevents;
+    }
+
+  enter_crit ();
+  if (notification_buffer_in_use)
+    {
+      DWORD info_size = notifications_size;
+      Lisp_Object cs = intern ("utf-16le");
+      Lisp_Object obj = w32_get_watch_object (notifications_desc);
+
+      /* notifications_size could be zero when the buffer of
+         notifications overflowed on the OS level, or when the
+         directory being watched was itself deleted.  Do nothing in
+         that case.  */
+      if (info_size
+          && !NILP (obj) && CONSP (obj))
+        {
+          Lisp_Object callback = XCDR (obj);
+
+          EVENT_INIT (inev);
+
+          while (info_size >= min_size)
+            {
+              Lisp_Object utf_16_fn
+                = make_unibyte_string ((char *)fni->FileName,
+                                       fni->FileNameLength);
+              /* Note: mule-conf is preloaded, so utf-16le must
+                 already be defined at this point.  */
+              Lisp_Object fname
+                = code_convert_string_norecord (utf_16_fn, cs, 0);
+              Lisp_Object action = lispy_file_action (fni->Action);
+
+              inev.kind = FILE_NOTIFY_EVENT;
+              inev.code = (ptrdiff_t)XINT (XIL ((EMACS_INT)notifications_desc));
+              inev.timestamp = GetTickCount ();
+              inev.modifiers = 0;
+              inev.frame_or_window = callback;
+              inev.arg = Fcons (action, fname);
+              kbd_buffer_store_event_hold (&inev, hold_quit);
+
+              if (!fni->NextEntryOffset)
+                break;
+              p += fni->NextEntryOffset;
+              fni = (PFILE_NOTIFY_INFORMATION)p;
+              info_size -= fni->NextEntryOffset;
+            }
+        }
+      notification_buffer_in_use = 0;
+    }
+  leave_crit ();
+  return nevents;
+}
+
 /* 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
    before w32_msg_pump in w32fns.c.)
@@ -619,12 +687,16 @@ w32_console_read_socket (struct terminal *terminal,
 
   for (;;)
     {
+      int nfnotify = handle_file_notifications (hold_quit);
+
       nev = fill_queue (0);
       if (nev <= 0)
         {
           /* If nev == -1, there was some kind of error
-             If nev == 0 then waitp must be zero and no events were available
+             If nev == 0 then no events were available
              so return.  */
+          if (nfnotify)
+            nev = 0;
           break;
         }
 
diff --git a/src/w32notify.c b/src/w32notify.c
new file mode 100644
index 00000000000..3095103484a
--- /dev/null
+++ b/src/w32notify.c
@@ -0,0 +1,631 @@
+/* Filesystem notifications support for GNU Emacs on the Microsoft Windows API.
+   Copyright (C) 2012  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/>.  */
+
+/* Written by Eli Zaretskii <eliz@gnu.org>.
+
+   Design overview:
+
+   For each watch request, we launch a separate worker thread.  The
+   worker thread runs the watch_worker function, which issues an
+   asynchronous call to ReadDirectoryChangesW, and then waits in
+   SleepEx for that call to complete.  Waiting in SleepEx puts the
+   thread in an "alertable" state, so it wakes up when either (a) the
+   call to ReadDirectoryChangesW completes, or (b) the main thread
+   instructs the worker thread to terminate by sending it an APC, see
+   below.
+
+   When the ReadDirectoryChangesW call completes, its completion
+   routine watch_completion is automatically called.  watch_completion
+   stashes the received file events in a buffer used to communicate
+   them to the main thread (using a critical section, so that several
+   threads could use the same buffer), posts a special message,
+   WM_EMACS_FILENOTIFY, to the Emacs's message queue, and returns.
+   That causes the SleepEx function call inside watch_worker to
+   return, and watch_worker then issues another call to
+   ReadDirectoryChangesW.  (Except when it does not, see below.)
+
+   In a GUI session, The WM_EMACS_FILENOTIFY message, posted to the
+   message queue gets dispatched to the main Emacs window procedure,
+   which queues it for processing by w32_read_socket.  When
+   w32_read_socket sees this message, it accesses the buffer with file
+   notifications (using a critical section), extracts the information,
+   converts it to a series of FILE_NOTIFY_EVENT events, and stuffs
+   them into the input event queue to be processed by keyboard.c input
+   machinery (read_char via a call to kbd_buffer_get_event).
+
+   In a non-GUI session, we send the WM_EMACS_FILENOTIFY message to
+   the main (a.k.a. "Lisp") thread instead, since there are no window
+   procedures in console programs.  That message wakes up
+   MsgWaitForMultipleObjects inside sys_select, which then signals to
+   its caller that some keyboard input is available.  This causes
+   w32_console_read_socket to be called, which accesses the buffer
+   with file notifications and stuffs them into the input event queue
+   for keyboard.c to process.
+
+   When the FILE_NOTIFY_EVENT event is processed by keyboard.c's
+   kbd_buffer_get_event, it is converted to a Lispy event that can be
+   bound to a command.  The default binding is w32notify-handle-event,
+   defined on subr.el.
+
+   After w32_read_socket or w32_console_read_socket are done
+   processing the notifications, they reset a flag signaling to all
+   watch worker threads that the notifications buffer is available for
+   more input.
+
+   When the watch is removed by a call to w32notify-rm-watch, the main
+   thread requests that the worker thread terminates by queuing an APC
+   for the worker thread.  The APC specifies the watch_end function to
+   be called.  watch_end calls CancelIo on the outstanding
+   ReadDirectoryChangesW call and closes the handle on which the
+   watched directory was open.  When watch_end returns, the
+   watch_completion function is called one last time with the
+   ERROR_OPERATION_ABORTED status, which causes it to clean up and set
+   a flag telling watch_worker to exit without issuing another
+   ReadDirectoryChangesW call.  Since watch_worker is the thread
+   procedure of the worker thread, exiting it causes the thread to
+   exit.  The main thread waits for some time for the worker thread to
+   exit, and if it doesn't, terminates it forcibly.  */
+
+#include <stddef.h>
+#include <errno.h>
+
+/* must include CRT headers *before* config.h */
+#include <config.h>
+
+#include <windows.h>
+
+#include "lisp.h"
+#include "w32term.h"    /* for enter_crit/leave_crit and WM_EMACS_FILENOTIFY */
+#include "w32common.h"  /* for OS version data */
+#include "w32.h"        /* for w32_strerror */
+#include "coding.h"
+#include "keyboard.h"
+#include "frame.h"      /* needed by termhooks.h */
+#include "termhooks.h"  /* for FILE_NOTIFY_EVENT */
+
+#define DIRWATCH_SIGNATURE 0x01233210
+
+struct notification {
+  BYTE *buf;            /* buffer for ReadDirectoryChangesW */
+  OVERLAPPED *io_info;  /* the OVERLAPPED structure for async I/O */
+  BOOL subtree;         /* whether to watch subdirectories */
+  DWORD filter;         /* bit mask for events to watch */
+  char *watchee;        /* the file we are interested in */
+  HANDLE dir;           /* handle to the watched directory */
+  HANDLE thr;           /* handle to the thread that watches */
+  volatile int terminate; /* if non-zero, request for the thread to terminate */
+  unsigned signature;
+};
+
+/* Used for communicating notifications to the main thread.  */
+volatile int notification_buffer_in_use;
+BYTE file_notifications[16384];
+DWORD notifications_size;
+void *notifications_desc;
+
+static Lisp_Object Qfile_name, Qdirectory_name, Qattributes, Qsize;
+static Lisp_Object Qlast_write_time, Qlast_access_time, Qcreation_time;
+static Lisp_Object Qsecurity_desc, Qsubtree, watch_list;
+
+/* Signal to the main thread that we have file notifications for it to
+   process.  */
+static void
+send_notifications (BYTE *info, DWORD info_size, void *desc,
+                    volatile int *terminate)
+{
+  int done = 0;
+  FRAME_PTR f = SELECTED_FRAME ();
+
+  /* A single buffer is used to communicate all notifications to the
+     main thread.  Since both the main thread and several watcher
+     threads could be active at the same time, we use a critical area
+     and an "in-use" flag to synchronize them.  A watcher thread can
+     only put its notifications in the buffer if it acquires the
+     critical area and finds the "in-use" flag reset.  The main thread
+     resets the flag after it is done processing notifications.
+
+     FIXME: is there a better way of dealing with this?  */
+  while (!done && !*terminate)
+    {
+      enter_crit ();
+      if (!notification_buffer_in_use)
+        {
+          if (info_size)
+            memcpy (file_notifications, info, info_size);
+          notifications_size = info_size;
+          notifications_desc = desc;
+          /* If PostMessage fails, the message queue is full.  If that
+             happens, the last thing they will worry about is file
+             notifications.  So we effectively discard the
+             notification in that case.  */
+          if ((FRAME_TERMCAP_P (f)
+               /* We send the message to the main (a.k.a. "Lisp")
+                  thread, where it will wake up MsgWaitForMultipleObjects
+                  inside sys_select, causing it to report that there's
+                  some keyboard input available.  This will in turn cause
+                  w32_console_read_socket to be called, which will pick
+                  up the file notifications.  */
+               && PostThreadMessage (dwMainThreadId, WM_EMACS_FILENOTIFY, 0, 0))
+              || (FRAME_W32_P (f)
+                  && PostMessage (FRAME_W32_WINDOW (f),
+                                  WM_EMACS_FILENOTIFY, 0, 0)))
+            notification_buffer_in_use = 1;
+          done = 1;
+        }
+      leave_crit ();
+      if (!done)
+        Sleep (5);
+    }
+}
+
+/* An APC routine to cancel outstanding directory watch.  Invoked by
+   the main thread via QueueUserAPC.  This is needed because only the
+   thread that issued the ReadDirectoryChangesW call can call CancelIo
+   to cancel that.  (CancelIoEx is only available since Vista, so we
+   cannot use it on XP.)  */
+VOID CALLBACK
+watch_end (ULONG_PTR arg)
+{
+  HANDLE hdir = (HANDLE)arg;
+
+  if (hdir && hdir != INVALID_HANDLE_VALUE)
+    {
+      CancelIo (hdir);
+      CloseHandle (hdir);
+    }
+}
+
+/* A completion routine (a.k.a. "APC function") for handling events
+   read by ReadDirectoryChangesW.  Called by the OS when the thread
+   which issued the asynchronous ReadDirectoryChangesW call is in the
+   "alertable state", i.e. waiting inside SleepEx call.  */
+VOID CALLBACK
+watch_completion (DWORD status, DWORD bytes_ret, OVERLAPPED *io_info)
+{
+  struct notification *dirwatch;
+
+  /* Who knows what happened?  Perhaps the OVERLAPPED structure was
+     freed by someone already?  In any case, we cannot do anything
+     with this request, so just punt and skip it.  FIXME: should we
+     raise the 'terminate' flag in this case?  */
+  if (!io_info)
+    return;
+
+  /* We have a pointer to our dirwatch structure conveniently stashed
+     away in the hEvent member of the OVERLAPPED struct.  According to
+     MSDN documentation of ReadDirectoryChangesW: "The hEvent member
+     of the OVERLAPPED structure is not used by the system, so you can
+     use it yourself."  */
+  dirwatch = (struct notification *)io_info->hEvent;
+  if (status == ERROR_OPERATION_ABORTED)
+    {
+      /* We've been called because the main thread told us to issue
+         CancelIo on the directory we watch, and watch_end did so.
+         The directory handle is already closed.  We should clean up
+         and exit, signalling to the thread worker routine not to
+         issue another call to ReadDirectoryChangesW.  Note that we
+         don't free the dirwatch object itself nor the memory consumed
+         by its buffers; this is done by the main thread in
+         remove_watch.  Calling malloc/free from a thread other than
+         the main thread is a no-no.  */
+      dirwatch->dir = NULL;
+      dirwatch->terminate = 1;
+    }
+  else
+    {
+      /* Tell the main thread we have notifications for it.  */
+      send_notifications (dirwatch->buf, bytes_ret, dirwatch,
+                          &dirwatch->terminate);
+    }
+}
+
+/* Worker routine for the watch thread.  */
+static DWORD WINAPI
+watch_worker (LPVOID arg)
+{
+  struct notification *dirwatch = (struct notification *)arg;
+
+  do {
+    BOOL status;
+    DWORD sleep_result;
+    DWORD bytes_ret = 0;
+
+    if (dirwatch->dir)
+      {
+        status = ReadDirectoryChangesW (dirwatch->dir, dirwatch->buf, 16384,
+                                        dirwatch->subtree, dirwatch->filter,
+                                        &bytes_ret,
+                                        dirwatch->io_info, watch_completion);
+        if (!status)
+          {
+            DebPrint (("watch_worker, abnormal exit: %lu\n", GetLastError ()));
+            /* We cannot remove the dirwatch object from watch_list,
+               because we are in a separate thread.  For the same
+               reason, we also cannot free memory consumed by the
+               buffers allocated for the dirwatch object.  So we close
+               the directory handle, but do not free the object itself
+               or its buffers.  We also don't touch the signature.
+               This way, remove_watch can still identify the object,
+               remove it, and free its memory.  */
+            CloseHandle (dirwatch->dir);
+            dirwatch->dir = NULL;
+            return 1;
+          }
+      }
+    /* Sleep indefinitely until awoken by the I/O completion, which
+       could be either a change notification or a cancellation of the
+       watch.  */
+    sleep_result = SleepEx (INFINITE, TRUE);
+  } while (!dirwatch->terminate);
+
+  return 0;
+}
+
+/* Launch a thread to watch changes to FILE in a directory open on
+   handle HDIR.  */
+static struct notification *
+start_watching (const char *file, HANDLE hdir, BOOL subdirs, DWORD flags)
+{
+  struct notification *dirwatch = xzalloc (sizeof (struct notification));
+  HANDLE thr;
+
+  dirwatch->signature = DIRWATCH_SIGNATURE;
+  dirwatch->buf = xmalloc (16384);
+  dirwatch->io_info = xzalloc (sizeof(OVERLAPPED));
+  /* Stash a pointer to dirwatch structure for use by the completion
+     routine.  According to MSDN documentation of ReadDirectoryChangesW:
+     "The hEvent member of the OVERLAPPED structure is not used by the
+     system, so you can use it yourself." */
+  dirwatch->io_info->hEvent = dirwatch;
+  dirwatch->subtree = subdirs;
+  dirwatch->filter = flags;
+  dirwatch->watchee = xstrdup (file);
+  dirwatch->terminate = 0;
+  dirwatch->dir = hdir;
+
+  /* See w32proc.c where it calls CreateThread for the story behind
+     the 2nd and 5th argument in the call to CreateThread.  */
+  dirwatch->thr = CreateThread (NULL, 64 * 1024, watch_worker, (void *)dirwatch,
+                                0x00010000, NULL);
+
+  if (!dirwatch->thr)
+    {
+      xfree (dirwatch->buf);
+      xfree (dirwatch->io_info);
+      xfree (dirwatch->watchee);
+      xfree (dirwatch);
+      dirwatch = NULL;
+    }
+  return dirwatch;
+}
+
+/* Called from the main thread to start watching FILE in PARENT_DIR,
+   subject to FLAGS.  If SUBDIRS is TRUE, watch the subdirectories of
+   PARENT_DIR as well.  Value is a pointer to 'struct notification'
+   used by the thread that watches the changes.  */
+static struct notification *
+add_watch (const char *parent_dir, const char *file, BOOL subdirs, DWORD flags)
+{
+  HANDLE hdir;
+  struct notification *dirwatch = NULL;
+
+  if (!file || !*file)
+    return NULL;
+
+  hdir = CreateFile (parent_dir,
+                     FILE_LIST_DIRECTORY,
+                     /* FILE_SHARE_DELETE doesn't preclude other
+                        processes from deleting files inside
+                        parent_dir.  */
+                     FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE,
+                     NULL, OPEN_EXISTING,
+                     FILE_FLAG_BACKUP_SEMANTICS | FILE_FLAG_OVERLAPPED,
+                     NULL);
+  if (hdir == INVALID_HANDLE_VALUE)
+    return NULL;
+
+  if ((dirwatch = start_watching (file, hdir, subdirs, flags)) == NULL)
+    CloseHandle (hdir);
+
+  return dirwatch;
+}
+
+/* Stop watching a directory specified by a pointer to its dirwatch object.  */
+static int
+remove_watch (struct notification *dirwatch)
+{
+  if (dirwatch && dirwatch->signature == DIRWATCH_SIGNATURE)
+    {
+      int i;
+      BOOL status;
+      DWORD exit_code, err;
+
+      /* Only the thread that issued the outstanding I/O call can call
+         CancelIo on it.  (CancelIoEx is available only since Vista.)
+         So we need to queue an APC for the worker thread telling it
+         to terminate.  */
+      if (!QueueUserAPC (watch_end, dirwatch->thr, (ULONG_PTR)dirwatch->dir))
+        DebPrint (("QueueUserAPC failed (%lu)!\n", GetLastError ()));
+      /* We also set the terminate flag, for when the thread is
+         waiting on the critical section that never gets acquired.
+         FIXME: is there a cleaner method?  Using SleepEx there is a
+         no-no, as that will lead to recursive APC invocations and
+         stack overflow.  */
+      dirwatch->terminate = 1;
+      /* Wait for the thread to exit.  FIXME: is there a better method
+         that is not overly complex?  */
+      for (i = 0; i < 50; i++)
+        {
+          if (!((status = GetExitCodeThread (dirwatch->thr, &exit_code))
+                && exit_code == STILL_ACTIVE))
+            break;
+          Sleep (10);
+        }
+      if ((status == FALSE && (err = GetLastError ()) == ERROR_INVALID_HANDLE)
+          || exit_code == STILL_ACTIVE)
+        {
+          if (!(status == FALSE && err == ERROR_INVALID_HANDLE))
+            {
+              TerminateThread (dirwatch->thr, 0);
+              if (dirwatch->dir)
+                CloseHandle (dirwatch->dir);
+            }
+        }
+
+      /* Clean up.  */
+      if (dirwatch->thr)
+        {
+          CloseHandle (dirwatch->thr);
+          dirwatch->thr = NULL;
+        }
+      xfree (dirwatch->buf);
+      xfree (dirwatch->io_info);
+      xfree (dirwatch->watchee);
+      xfree (dirwatch);
+
+      return 0;
+    }
+  else
+    {
+      DebPrint (("Unknown dirwatch object!\n"));
+      return -1;
+    }
+}
+
+static DWORD
+filter_list_to_flags (Lisp_Object filter_list)
+{
+  DWORD flags = 0;
+
+  if (NILP (filter_list))
+    return flags;
+
+  if (!NILP (Fmember (Qfile_name, filter_list)))
+    flags |= FILE_NOTIFY_CHANGE_FILE_NAME;
+  if (!NILP (Fmember (Qdirectory_name, filter_list)))
+    flags |= FILE_NOTIFY_CHANGE_DIR_NAME;
+  if (!NILP (Fmember (Qattributes, filter_list)))
+    flags |= FILE_NOTIFY_CHANGE_ATTRIBUTES;
+  if (!NILP (Fmember (Qsize, filter_list)))
+    flags |= FILE_NOTIFY_CHANGE_SIZE;
+  if (!NILP (Fmember (Qlast_write_time, filter_list)))
+    flags |= FILE_NOTIFY_CHANGE_LAST_WRITE;
+  if (!NILP (Fmember (Qlast_access_time, filter_list)))
+    flags |= FILE_NOTIFY_CHANGE_LAST_ACCESS;
+  if (!NILP (Fmember (Qcreation_time, filter_list)))
+    flags |= FILE_NOTIFY_CHANGE_CREATION;
+  if (!NILP (Fmember (Qsecurity_desc, filter_list)))
+    flags |= FILE_NOTIFY_CHANGE_SECURITY;
+
+  return flags;
+}
+
+DEFUN ("w32notify-add-watch", Fw32notify_add_watch,
+       Sw32notify_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 `w32notify-rm-watch' to cancel the watch.
+
+Value is a descriptor for the added watch, or nil if the file
+cannot be watched.
+
+FILTER is a list of conditions for reporting an event.  It can include
+the following symbols:
+
+  'file-name'          -- report file creation, deletion, or renaming
+  'directory-name'     -- report directory creation, deletion, or renaming
+  'attributes'         -- report changes in attributes
+  'size'               -- report changes in file-size
+  'last-write-time'    -- report changes in last-write time
+  'last-access-time'   -- report changes in last-access time
+  'creation-time'      -- report changes in creation time
+  'security-desc'      -- report changes in security descriptor
+
+If FILE is a directory, and FILTER includes 'subtree', then all the
+subdirectories will also be watched and changes in them reported.
+
+When any event happens that satisfies the conditions specified by
+FILTER, Emacs will call the CALLBACK function passing it a single
+argument EVENT, which is of the form
+
+  (DESCRIPTOR ACTION FILE)
+
+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:
+
+  'added'        -- FILE was added
+  'removed'      -- FILE was deleted
+  'modified'     -- FILE's contents or its attributes were modified
+  'renamed-from' -- a file was renamed whose old name was FILE
+  'renamed-to'   -- a file was renamed and its new name is FILE
+
+FILE is the name of the file whose event is being reported.  */)
+  (Lisp_Object file, Lisp_Object filter, Lisp_Object callback)
+{
+  Lisp_Object encoded_file, watch_object, watch_descriptor;
+  char parent_dir[MAX_PATH], *basename;
+  size_t fn_len;
+  DWORD flags;
+  BOOL subdirs = FALSE;
+  struct notification *dirwatch = NULL;
+  Lisp_Object lisp_errstr;
+  char *errstr;
+
+  CHECK_LIST (filter);
+
+  /* The underlying features are available only since XP.  */
+  if (os_subtype == OS_9X
+      || (w32_major_version == 5 && w32_major_version < 1))
+    {
+      errno = ENOSYS;
+      report_file_error ("Watching filesystem events is not supported",
+                         Qnil);
+    }
+
+  /* We need a full absolute file name of FILE, and we need to remove
+     any trailing slashes from it, so that GetFullPathName below gets
+     the basename part correctly.  */
+  file = Fdirectory_file_name (Fexpand_file_name (file, Qnil));
+  encoded_file = ENCODE_FILE (file);
+
+  fn_len = GetFullPathName (SDATA (encoded_file), MAX_PATH, parent_dir,
+                            &basename);
+  if (!fn_len)
+    {
+      errstr = w32_strerror (0);
+      errno = EINVAL;
+      if (!NILP (Vlocale_coding_system))
+        lisp_errstr
+          = code_convert_string_norecord (build_unibyte_string (errstr),
+                                          Vlocale_coding_system, 0);
+      else
+        lisp_errstr = build_string (errstr);
+      report_file_error ("GetFullPathName failed",
+                         Fcons (lisp_errstr, Fcons (file, Qnil)));
+    }
+  /* We need the parent directory without the slash that follows it.
+     If BASENAME is NULL, the argument was the root directory on its
+     drive.  */
+  if (basename)
+    basename[-1] = '\0';
+  else
+    subdirs = TRUE;
+
+  if (!NILP (Fmember (Qsubtree, filter)))
+    subdirs = TRUE;
+
+  flags = filter_list_to_flags (filter);
+
+  dirwatch = add_watch (parent_dir, basename, subdirs, flags);
+  if (!dirwatch)
+    {
+      DWORD err = GetLastError ();
+
+      errno = EINVAL;
+      if (err)
+        {
+          errstr = w32_strerror (err);
+          if (!NILP (Vlocale_coding_system))
+            lisp_errstr
+              = code_convert_string_norecord (build_unibyte_string (errstr),
+                                              Vlocale_coding_system, 0);
+          else
+            lisp_errstr = build_string (errstr);
+          report_file_error ("Cannot watch file",
+                             Fcons (lisp_errstr, Fcons (file, Qnil)));
+        }
+      else
+        report_file_error ("Cannot watch file", Fcons (file, Qnil));
+    }
+  /* Store watch object in watch list. */
+  watch_descriptor = XIL ((EMACS_INT)dirwatch);
+  watch_object = Fcons (watch_descriptor, callback);
+  watch_list = Fcons (watch_object, watch_list);
+
+  return watch_descriptor;
+}
+
+DEFUN ("w32notify-rm-watch", Fw32notify_rm_watch,
+       Sw32notify_rm_watch, 1, 1, 0,
+       doc: /* Remove an existing watch specified by its WATCH-DESCRIPTOR.
+
+WATCH-DESCRIPTOR should be an object returned by `w32notify-add-watch'.  */)
+     (Lisp_Object watch_descriptor)
+{
+  Lisp_Object watch_object;
+  struct notification *dirwatch;
+  int status = -1;
+
+  /* Remove the watch object from watch list.  Do this before freeing
+     the object, do that even if we fail to free it, watch_list is
+     kept free of junk.  */
+  watch_object = Fassoc (watch_descriptor, watch_list);
+  if (!NILP (watch_object))
+    {
+      watch_list = Fdelete (watch_object, watch_list);
+      dirwatch = (struct notification *)XLI (watch_descriptor);
+      if (w32_valid_pointer_p (dirwatch, sizeof(struct notification)))
+        status = remove_watch (dirwatch);
+    }
+
+  if (status == -1)
+    report_file_error ("Invalid watch descriptor", Fcons (watch_descriptor,
+                                                          Qnil));
+
+  return Qnil;
+}
+
+Lisp_Object
+w32_get_watch_object (void *desc)
+{
+  Lisp_Object descriptor = XIL ((EMACS_INT)desc);
+
+  /* This is called from the input queue handling code, inside a
+     critical section, so we cannot possibly QUIT if watch_list is not
+     in the right condition.  */
+  return NILP (watch_list) ? Qnil : assoc_no_quit (descriptor, watch_list);
+}
+
+void
+globals_of_w32notify (void)
+{
+  watch_list = Qnil;
+}
+
+void
+syms_of_w32notify (void)
+{
+  DEFSYM (Qfile_name, "file-name");
+  DEFSYM (Qdirectory_name, "directory-name");
+  DEFSYM (Qattributes, "attributes");
+  DEFSYM (Qsize, "size");
+  DEFSYM (Qlast_write_time, "last-write-time");
+  DEFSYM (Qlast_access_time, "last-access-time");
+  DEFSYM (Qcreation_time, "creation-time");
+  DEFSYM (Qsecurity_desc, "security-desc");
+  DEFSYM (Qsubtree, "subtree");
+
+  defsubr (&Sw32notify_add_watch);
+  defsubr (&Sw32notify_rm_watch);
+
+  staticpro (&watch_list);
+
+  Fprovide (intern_c_string ("w32notify"), Qnil);
+}
diff --git a/src/w32proc.c b/src/w32proc.c
index d888200c556..ddc6826df98 100644
--- a/src/w32proc.c
+++ b/src/w32proc.c
@@ -2018,7 +2018,24 @@ count_children:
              (*) Note that MsgWaitForMultipleObjects above is an
              internal dispatch point for messages that are sent to
              windows created by this thread.  */
-          drain_message_queue ();
+          if (drain_message_queue ()
+              /* If drain_message_queue returns non-zero, that means
+                 we received a WM_EMACS_FILENOTIFY message.  If this
+                 is a TTY frame, we must signal the caller that keyboard
+                 input is available, so that w32_console_read_socket
+                 will be called to pick up the notifications.  If we
+                 don't do that, file notifications will only work when
+                 the Emacs TTY frame has focus.  */
+              && FRAME_TERMCAP_P (SELECTED_FRAME ())
+              /* they asked for stdin reads */
+              && FD_ISSET (0, &orfds)
+              /* the stdin handle is valid */
+              && keyboard_handle)
+            {
+              FD_SET (0, rfds);
+              if (nr == 0)
+                nr = 1;
+            }
         }
       else if (active >= nh)
         {
diff --git a/src/w32term.c b/src/w32term.c
index e26777543fb..7c53097e313 100644
--- a/src/w32term.c
+++ b/src/w32term.c
@@ -246,6 +246,8 @@ static void x_check_font (struct frame *, struct font *);
 #endif
 
 static Lisp_Object Qvendor_specific_keysyms;
+static Lisp_Object Qadded, Qremoved, Qmodified;
+static Lisp_Object Qrenamed_from, Qrenamed_to;
 
 
 /***********************************************************************
@@ -3204,6 +3206,124 @@ construct_drag_n_drop (struct input_event *result, W32Msg *msg, struct frame *f)
 }
 
 
+/* File event notifications (see w32notify.c).  */
+
+Lisp_Object
+lispy_file_action (DWORD action)
+{
+  static char unknown_fmt[] = "unknown-action(%d)";
+  Lisp_Object retval;
+
+  switch (action)
+    {
+    case FILE_ACTION_ADDED:
+      retval = Qadded;
+      break;
+    case FILE_ACTION_REMOVED:
+      retval = Qremoved;
+      break;
+    case FILE_ACTION_MODIFIED:
+      retval = Qmodified;
+      break;
+    case FILE_ACTION_RENAMED_OLD_NAME:
+      retval = Qrenamed_from;
+      break;
+    case FILE_ACTION_RENAMED_NEW_NAME:
+      retval = Qrenamed_to;
+      break;
+    default:
+      {
+        char buf[sizeof(unknown_fmt) - 1 + INT_STRLEN_BOUND (DWORD)];
+
+        sprintf (buf, unknown_fmt, action);
+        retval = intern (buf);
+      }
+      break;
+    }
+
+  return retval;
+}
+
+#ifdef WINDOWSNT
+/* Put file notifications into the Emacs input event queue.  This
+   function runs when the WM_EMACS_FILENOTIFY message arrives from a
+   watcher thread.  */
+static void
+queue_notifications (struct input_event *event, W32Msg *msg, struct frame *f,
+                     int *evcount)
+{
+  BYTE *p = file_notifications;
+  FILE_NOTIFY_INFORMATION *fni = (PFILE_NOTIFY_INFORMATION)p;
+  const DWORD min_size
+    = offsetof (FILE_NOTIFY_INFORMATION, FileName) + sizeof(wchar_t);
+  Lisp_Object frame;
+
+  /* We cannot process notification before Emacs is fully initialized,
+     since we need the UTF-16LE coding-system to be set up.  */
+  if (!initialized)
+    {
+      notification_buffer_in_use = 0;
+      return;
+    }
+
+  XSETFRAME (frame, f);
+
+  enter_crit ();
+  if (notification_buffer_in_use)
+    {
+      DWORD info_size = notifications_size;
+      Lisp_Object cs = intern ("utf-16le");
+      Lisp_Object obj = w32_get_watch_object (notifications_desc);
+
+      /* notifications_size could be zero when the buffer of
+         notifications overflowed on the OS level, or when the
+         directory being watched was itself deleted.  Do nothing in
+         that case.  */
+      if (info_size
+          && !NILP (obj) && CONSP (obj))
+        {
+          Lisp_Object callback = XCDR (obj);
+
+          while (info_size >= min_size)
+            {
+              Lisp_Object utf_16_fn
+                = make_unibyte_string ((char *)fni->FileName,
+                                       fni->FileNameLength);
+              /* Note: mule-conf is preloaded, so utf-16le must
+                 already be defined at this point.  */
+              Lisp_Object fname
+                = code_convert_string_norecord (utf_16_fn, cs, 0);
+              Lisp_Object action = lispy_file_action (fni->Action);
+
+              event->kind = FILE_NOTIFY_EVENT;
+              event->code
+                = (ptrdiff_t)XINT (XIL ((EMACS_INT)notifications_desc));
+              event->timestamp = msg->msg.time;
+              event->modifiers = 0;
+              event->frame_or_window = callback;
+              event->arg = Fcons (action, fname);
+              kbd_buffer_store_event (event);
+              (*evcount)++;
+
+              if (!fni->NextEntryOffset)
+                break;
+              p += fni->NextEntryOffset;
+              fni = (PFILE_NOTIFY_INFORMATION)p;
+              info_size -= fni->NextEntryOffset;
+            }
+        }
+      notification_buffer_in_use = 0;
+    }
+  else
+    DebPrint (("We were promised notifications, but in-use flag is zero!\n"));
+  leave_crit ();
+
+  /* We've stuffed all the events ourselves, so w32_read_socket shouldn't.  */
+  event->kind = NO_EVENT;
+}
+#endif
+
+
 /* Function to report a mouse movement to the mainstream Emacs code.
    The input handler calls this.
 
@@ -4836,6 +4956,14 @@ w32_read_socket (struct terminal *terminal,
           check_visibility = 1;
           break;
 
+#ifdef WINDOWSNT
+        case WM_EMACS_FILENOTIFY:
+          f = x_window_to_frame (dpyinfo, msg.msg.hwnd);
+          if (f)
+            queue_notifications (&inev, &msg, f, &count);
+          break;
+#endif
+
         default:
           /* Check for messages registered at runtime.  */
           if (msg.msg.message == msh_mousewheel)
@@ -6503,6 +6631,12 @@ syms_of_w32term (void)
 
   DEFSYM (Qvendor_specific_keysyms, "vendor-specific-keysyms");
 
+  DEFSYM (Qadded, "added");
+  DEFSYM (Qremoved, "removed");
+  DEFSYM (Qmodified, "modified");
+  DEFSYM (Qrenamed_from, "renamed-from");
+  DEFSYM (Qrenamed_to, "renamed-to");
+
   DEFVAR_INT ("w32-num-mouse-buttons",
               w32_num_mouse_buttons,
               doc: /* Number of physical mouse buttons.  */);
diff --git a/src/w32term.h b/src/w32term.h
index af1a79e21c9..35842e60c16 100644
--- a/src/w32term.h
+++ b/src/w32term.h
@@ -602,7 +602,8 @@ do { \
 #define WM_EMACS_PAINT                 (WM_EMACS_START + 20)
 #define WM_EMACS_BRINGTOTOP            (WM_EMACS_START + 21)
 #define WM_EMACS_INPUT_READY           (WM_EMACS_START + 22)
-#define WM_EMACS_END                   (WM_EMACS_START + 23)
+#define WM_EMACS_FILENOTIFY            (WM_EMACS_START + 23)
+#define WM_EMACS_END                   (WM_EMACS_START + 24)
 
 #define WND_FONTWIDTH_INDEX    (0)
 #define WND_LINEHEIGHT_INDEX   (4)
@@ -652,7 +653,7 @@ extern void deselect_palette (struct frame * f, HDC hdc);
 extern HDC get_frame_dc (struct frame * f);
 extern int release_frame_dc (struct frame * f, HDC hDC);
 
-extern void drain_message_queue (void);
+extern int drain_message_queue (void);
 
 extern BOOL get_next_msg (W32Msg *, BOOL);
 extern BOOL post_msg (W32Msg *);
@@ -662,10 +663,17 @@ extern BOOL parse_button (int, int, int *, int *);
 
 extern void w32_sys_ring_bell (struct frame *f);
 extern void x_delete_display (struct w32_display_info *dpyinfo);
+
+extern volatile int notification_buffer_in_use;
+extern BYTE file_notifications[16384];
+extern DWORD notifications_size;
+extern void *notifications_desc;
+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 *);
 
-
 /* Keypad command key support.  W32 doesn't have virtual keys defined
    for the function keys on the keypad (they are mapped to the standard
    function keys), so we define our own.  */
@@ -759,6 +767,7 @@ extern void syms_of_w32fns (void);
 
 extern void globals_of_w32menu (void);
 extern void globals_of_w32fns (void);
+extern void globals_of_w32notify (void);
 
 #ifdef CYGWIN
 extern int w32_message_fd;
diff --git a/src/w32xfns.c b/src/w32xfns.c
index cb452571665..8820edda6c2 100644
--- a/src/w32xfns.c
+++ b/src/w32xfns.c
@@ -315,16 +315,22 @@ prepend_msg (W32Msg *lpmsg)
   return (TRUE);
 }
 
-/* Process all messages in the current thread's queue.  */
-void
+/* Process all messages in the current thread's queue.  Value is 1 if
+   one of these messages was WM_EMACS_FILENOTIFY, zero otherwise.  */
+int
 drain_message_queue (void)
 {
   MSG msg;
+  int retval = 0;
+
   while (PeekMessage (&msg, NULL, 0, 0, PM_REMOVE))
     {
+      if (msg.message == WM_EMACS_FILENOTIFY)
+        retval = 1;
       TranslateMessage (&msg);
       DispatchMessage (&msg);
     }
+  return retval;
 }
 
 /* x_sync is a no-op on W32.  */
diff --git a/src/window.c b/src/window.c
index 0340044ca21..4631a898d3e 100644
--- a/src/window.c
+++ b/src/window.c
@@ -271,6 +271,35 @@ decode_valid_window (register Lisp_Object window)
   return w;
 }
 
+/* Called when W's buffer slot is changed.  ARG -1 means that W is about to
+   cease its buffer, and 1 means that W is about to set up the new one.  */
+
+static void
+adjust_window_count (struct window *w, int arg)
+{
+  eassert (eabs (arg) == 1);
+  if (BUFFERP (w->buffer))
+    {
+      struct buffer *b = XBUFFER (w->buffer);
+      
+      if (b->base_buffer)
+        b = b->base_buffer;
+      b->window_count += arg;
+      eassert (b->window_count >= 0);
+    }
+}
+
+/* Set W's buffer slot to VAL and recompute number
+   of windows showing VAL if it is a buffer.  */
+
+void
+wset_buffer (struct window *w, Lisp_Object val)
+{
+  adjust_window_count (w, -1);
+  w->buffer = val;
+  adjust_window_count (w, 1);
+}
+
 /* Build a frequently used 4-integer (X Y W H) list.  */
 
 static Lisp_Object
@@ -1464,6 +1493,7 @@ if it isn't already recorded.  */)
       && !noninteractive)
     {
       struct text_pos startp;
+      ptrdiff_t charpos = marker_position (w->start);
       struct it it;
       struct buffer *old_buffer = NULL;
       void *itdata = NULL;
@@ -1481,9 +1511,9 @@ if it isn't already recorded.  */)
          `-l' containing a call to `rmail' with subsequent other
          commands.  At the end, W->start happened to be BEG, while
          rmail had already narrowed the buffer.  */
-      if (XMARKER (w->start)->charpos < BEGV)
+      if (charpos < BEGV)
         SET_TEXT_POS (startp, BEGV, BEGV_BYTE);
-      else if (XMARKER (w->start)->charpos > ZV)
+      else if (charpos > ZV)
         SET_TEXT_POS (startp, ZV, ZV_BYTE);
       else
         SET_TEXT_POS_FROM_MARKER (startp, w->start);
@@ -1606,7 +1636,7 @@ display row, and VPOS is the row number (0-based) containing POS.  */)
   else if (w == XWINDOW (selected_window))
     posint = PT;
   else
-    posint = XMARKER (w->pointm)->charpos;
+    posint = marker_position (w->pointm);
 
   /* If position is above window start or outside buffer boundaries,
      or if window start is out of range, position is not visible.  */
@@ -1952,7 +1982,7 @@ unshow_buffer (register struct window *w)
            && EQ (buf, XWINDOW (BVAR (b, last_selected_window))->buffer)))
     temp_set_point_both (b,
                          clip_to_bounds (BUF_BEGV (b),
-                                         XMARKER (w->pointm)->charpos,
+                                         marker_position (w->pointm),
                                          BUF_ZV (b)),
                          clip_to_bounds (BUF_BEGV_BYTE (b),
                                          marker_byte_position (w->pointm),
@@ -2959,22 +2989,24 @@ replace_buffer_in_windows (Lisp_Object buffer)
   call1 (Qreplace_buffer_in_windows, buffer);
 }
 
-
-/* Safely replace BUFFER with some other buffer in all windows of all
-   frames, even those on other keyboards.  */
+/* If BUFFER is shown in a window, safely replace it with some other
+   buffer in all windows of all frames, even those on other keyboards.  */
 
 void
 replace_buffer_in_windows_safely (Lisp_Object buffer)
 {
-  Lisp_Object tail, frame;
+  if (buffer_window_count (XBUFFER (buffer)))
+    {
+      Lisp_Object tail, frame;
 
-  /* A single call to window_loop won't do the job because it only
-     considers frames on the current keyboard.  So loop manually over
-     frames, and handle each one.  */
-  FOR_EACH_FRAME (tail, frame)
-    window_loop (REPLACE_BUFFER_IN_WINDOWS_SAFELY, buffer, 1, frame);
+      /* A single call to window_loop won't do the job because it only
+         considers frames on the current keyboard.  So loop manually over
+         frames, and handle each one.  */
+      FOR_EACH_FRAME (tail, frame)
+        window_loop (REPLACE_BUFFER_IN_WINDOWS_SAFELY, buffer, 1, frame);
+    }
 }
-
+
 /* If *ROWS or *COLS are too small a size for FRAME, set them to the
    minimum allowable size.  */
 
@@ -3309,11 +3341,11 @@ displaying that buffer.  */)
 
   if (STRINGP (object))
     object = Fget_buffer (object);
-  if (BUFFERP (object) && BUFFER_LIVE_P (XBUFFER (object)))
+  if (BUFFERP (object) && BUFFER_LIVE_P (XBUFFER (object))
+      && buffer_window_count (XBUFFER (object)))
     {
-      /* Walk all windows looking for buffer, and force update
-         of each of those windows.  */
-
+      /* If buffer is live and shown in at least one window, find
+         all windows showing this buffer and force update of them.  */
       object = window_loop (REDISPLAY_BUFFER_WINDOWS, object, 0, Qvisible);
       return NILP (object) ? Qnil : Qt;
     }
@@ -3392,6 +3424,8 @@ make_parent_window (Lisp_Object window, int horflag)
   memcpy ((char *) p + sizeof (struct vectorlike_header),
           (char *) o + sizeof (struct vectorlike_header),
           word_size * VECSIZE (struct window));
+  /* P's buffer slot may change from nil to a buffer.  */
+  adjust_window_count (p, 1);
   XSETWINDOW (parent, p);
 
   p->sequence_number = ++sequence_number;
@@ -4589,7 +4623,7 @@ window_scroll_pixel_based (Lisp_Object window, int n, int whole, int noerror)
       /* Set the window start, and set up the window for redisplay.  */
       set_marker_restricted (w->start, make_number (pos),
                              w->buffer);
-      bytepos = XMARKER (w->start)->bytepos;
+      bytepos = marker_byte_position (w->start);
       w->start_at_line_beg = (pos == BEGV || FETCH_BYTE (bytepos - 1) == '\n');
       w->update_mode_line = 1;
       w->last_modified = 0;
@@ -5089,6 +5123,7 @@ displayed_window_lines (struct window *w)
 {
   struct it it;
   struct text_pos start;
+  ptrdiff_t charpos = marker_position (w->start);
   int height = window_box_height (w);
   struct buffer *old_buffer;
   int bottom_y;
@@ -5105,9 +5140,9 @@ displayed_window_lines (struct window *w)
   /* In case W->start is out of the accessible range, do something
      reasonable.  This happens in Info mode when Info-scroll-down
      calls (recenter -1) while W->start is 1.  */
-  if (XMARKER (w->start)->charpos < BEGV)
+  if (charpos < BEGV)
     SET_TEXT_POS (start, BEGV, BEGV_BYTE);
-  else if (XMARKER (w->start)->charpos > ZV)
+  else if (charpos > ZV)
     SET_TEXT_POS (start, ZV, ZV_BYTE);
   else
     SET_TEXT_POS_FROM_MARKER (start, w->start);
@@ -5535,7 +5570,7 @@ the return value is nil.  Otherwise the value is t.  */)
             && WINDOWP (selected_window)
             && EQ (XWINDOW (selected_window)->buffer, new_current_buffer)
             && !EQ (selected_window, data->current_window))
-          old_point = XMARKER (XWINDOW (data->current_window)->pointm)->charpos;
+          old_point = marker_position (XWINDOW (data->current_window)->pointm);
         else
           old_point = PT;
       else
@@ -5550,7 +5585,7 @@ the return value is nil.  Otherwise the value is t.  */)
         if (EQ (XWINDOW (data->current_window)->buffer, new_current_buffer)
             /* If current_window = selected_window, its point is in BUF_PT.  */
             && !EQ (selected_window, data->current_window))
-          old_point = XMARKER (XWINDOW (data->current_window)->pointm)->charpos;
+          old_point = marker_position (XWINDOW (data->current_window)->pointm);
         else
           old_point = BUF_PT (XBUFFER (new_current_buffer));
     }
diff --git a/src/window.h b/src/window.h
index 2a12226c0aa..f4f42a25af4 100644
--- a/src/window.h
+++ b/src/window.h
@@ -351,11 +351,6 @@ struct window
 /* Most code should use these functions to set Lisp fields in struct
    window.  */
 WINDOW_INLINE void
-wset_buffer (struct window *w, Lisp_Object val)
-{
-  w->buffer = val;
-}
-WINDOW_INLINE void
 wset_frame (struct window *w, Lisp_Object val)
 {
   w->frame = val;
@@ -947,11 +942,6 @@ extern int windows_or_buffers_changed;
 
 extern int cursor_type_changed;
 
-/* Number of windows displaying the selected buffer.  Normally this is
-   1, but it can be more.  */
-
-extern int buffer_shared;
-
 /* If *ROWS or *COLS are too small a size for FRAME, set them to the
    minimum allowable size.  */
 
@@ -997,6 +987,8 @@ extern int window_body_cols (struct window *w);
 extern void temp_output_buffer_show (Lisp_Object);
 extern void replace_buffer_in_windows (Lisp_Object);
 extern void replace_buffer_in_windows_safely (Lisp_Object);
+/* This looks like a setter, but it is a bit special.  */
+extern void wset_buffer (struct window *, Lisp_Object);
 extern void init_window_once (void);
 extern void init_window (void);
 extern void syms_of_window (void);
diff --git a/src/xdisp.c b/src/xdisp.c
index e1b12b8464c..ccd0bb07487 100644
--- a/src/xdisp.c
+++ b/src/xdisp.c
@@ -517,11 +517,6 @@ Lisp_Object Qmenu_bar_update_hook;
 
 static int overlay_arrow_seen;
 
-/* Number of windows showing the buffer of the selected
-   window (or another buffer with the same base buffer).  */
-
-int buffer_shared;
-
 /* Vector containing glyphs for an ellipsis `...'.  */
 
 static Lisp_Object default_invis_vector[3];
@@ -9554,7 +9549,7 @@ message_dolog (const char *m, ptrdiff_t nbytes, int nlflag, int multibyte)
               del_range_both (BEG, BEG_BYTE, PT, PT_BYTE, 0);
             }
         }
-      BEGV = XMARKER (oldbegv)->charpos;
+      BEGV = marker_position (oldbegv);
       BEGV_BYTE = marker_byte_position (oldbegv);
 
       if (zv_at_end)
@@ -9564,7 +9559,7 @@ message_dolog (const char *m, ptrdiff_t nbytes, int nlflag, int multibyte)
         }
       else
         {
-          ZV = XMARKER (oldzv)->charpos;
+          ZV = marker_position (oldzv);
           ZV_BYTE = marker_byte_position (oldzv);
         }
 
@@ -9573,8 +9568,8 @@ message_dolog (const char *m, ptrdiff_t nbytes, int nlflag, int multibyte)
       else
         /* We can't do Fgoto_char (oldpoint) because it will run some
            Lisp code.  */
-        TEMP_SET_PT_BOTH (XMARKER (oldpoint)->charpos,
-                          XMARKER (oldpoint)->bytepos);
+        TEMP_SET_PT_BOTH (marker_position (oldpoint),
+                          marker_byte_position (oldpoint));
 
       UNGCPRO;
       unchain_marker (XMARKER (oldpoint));
@@ -10146,8 +10141,8 @@ with_echo_area_buffer_unwind_data (struct window *w)
     {
       XSETWINDOW (tmp, w); ASET (vector, i, tmp); ++i;
       ASET (vector, i, w->buffer); ++i;
-      ASET (vector, i, make_number (XMARKER (w->pointm)->charpos)); ++i;
-      ASET (vector, i, make_number (XMARKER (w->pointm)->bytepos)); ++i;
+      ASET (vector, i, make_number (marker_position (w->pointm))); ++i;
+      ASET (vector, i, make_number (marker_byte_position (w->pointm))); ++i;
     }
   else
     {
@@ -10948,9 +10943,8 @@ echo_area_display (int update_frame_p)
 static int
 buffer_shared_and_changed (void)
 {
-  /* The variable buffer_shared is set in redisplay_window and
-     indicates that we redisplay a buffer in different windows. */
-  return (buffer_shared > 1 && UNCHANGED_MODIFIED < MODIFF);
+  return (buffer_window_count (current_buffer) > 1
+          && UNCHANGED_MODIFIED < MODIFF);
 }
 
 /* Nonzero if W doesn't reflect the actual state of current buffer due
@@ -13531,10 +13525,6 @@ redisplay_internal (void)
       FOR_EACH_FRAME (tail, frame)
         XFRAME (frame)->updated_p = 0;
 
-      /* Recompute # windows showing selected buffer.  This will be
-         incremented each time such a window is displayed.  */
-      buffer_shared = 0;
-
       FOR_EACH_FRAME (tail, frame)
         {
           struct frame *f = XFRAME (frame);
@@ -13872,7 +13862,7 @@ mark_window_display_accurate_1 (struct window *w, int accurate_p)
           if (w == XWINDOW (selected_window))
             w->last_point = BUF_PT (b);
           else
-            w->last_point = XMARKER (w->pointm)->charpos;
+            w->last_point = marker_position (w->pointm);
         }
     }
 
@@ -15629,26 +15619,11 @@ redisplay_window (Lisp_Object window, int just_this_one_p)
   if (mode_line_update_needed (w))
     update_mode_line = 1;
 
-  /* Count number of windows showing the selected buffer.  An indirect
-     buffer counts as its base buffer.  */
-  if (!just_this_one_p)
-    {
-      struct buffer *current_base, *window_base;
-      current_base = current_buffer;
-      window_base = XBUFFER (XWINDOW (selected_window)->buffer);
-      if (current_base->base_buffer)
-        current_base = current_base->base_buffer;
-      if (window_base->base_buffer)
-        window_base = window_base->base_buffer;
-      if (current_base == window_base)
-        buffer_shared++;
-    }
-
   /* Point refers normally to the selected window.  For any other
      window, set up appropriate value.  */
   if (!EQ (window, selected_window))
     {
-      ptrdiff_t new_pt = XMARKER (w->pointm)->charpos;
+      ptrdiff_t new_pt = marker_position (w->pointm);
       ptrdiff_t new_pt_byte = marker_byte_position (w->pointm);
       if (new_pt < BEGV)
         {
@@ -21656,7 +21631,7 @@ decode_mode_spec (struct window *w, register int c, int field_width,
         if (mode_line_target == MODE_LINE_TITLE)
           return "";
 
-        startpos = XMARKER (w->start)->charpos;
+        startpos = marker_position (w->start);
         startpos_byte = marker_byte_position (w->start);
         height = WINDOW_TOTAL_LINES (w);
 
diff --git a/test/ChangeLog b/test/ChangeLog
index 21f0f29b73b..142dfcb42fd 100644
--- a/test/ChangeLog
+++ b/test/ChangeLog
@@ -1,3 +1,11 @@
+2012-12-11  Glenn Morris  <rgm@gnu.org>
+
+        * automated/f90.el (f90-test-bug13138): New test.
+
+2012-12-10  Rüdiger Sonderfeld  <ruediger@c-plusplus.de>
+
+        * automated/inotify-test.el: New test.
+
 2012-12-02  Chong Yidong  <cyd@gnu.org>
 
         * automated/ruby-mode-tests.el
diff --git a/test/automated/f90.el b/test/automated/f90.el
index 25b77f07ad3..7f412568ae3 100644
--- a/test/automated/f90.el
+++ b/test/automated/f90.el
@@ -154,5 +154,23 @@ end module modname")
     (f90-indent-line)
     (should (= 0 (current-indentation)))))
 
+(ert-deftest f90-test-bug13138 ()
+  "Test for http://debbugs.gnu.org/13138 ."
+  (with-temp-buffer
+    (f90-mode)
+    (insert "program prog
+  integer :: i = &
+#ifdef foo
+       & 1
+#else
+       & 2
+#endif
+
+  write(*,*) i
+end program prog")
+    (goto-char (point-min))
+    (forward-line 2)
+    (f90-indent-subprogram)
+    (should (= 0 (current-indentation)))))
 
 ;;; f90.el ends here
diff --git a/test/automated/inotify-test.el b/test/automated/inotify-test.el
new file mode 100644
index 00000000000..edda7ef0418
--- /dev/null
+++ b/test/automated/inotify-test.el
@@ -0,0 +1,60 @@
+;;; inotify-tests.el --- Test suite for inotify. -*- lexical-binding: t -*-
+
+;; Copyright (C) 2012 Free Software Foundation, Inc.
+
+;; Author: Rüdiger Sonderfeld <ruediger@c-plusplus.de>
+;; Keywords:       internal
+;; Human-Keywords: internal
+
+;; 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/>.
+
+;;; Code:
+
+(require 'ert)
+
+(when (featurep 'inotify)
+
+  ;; (ert-deftest filewatch-file-watch-aspects-check ()
+  ;;   "Test whether `file-watch' properly checks the aspects."
+  ;;   (let ((temp-file (make-temp-file "filewatch-aspects")))
+  ;;     (should (stringp temp-file))
+  ;;     (should-error (file-watch temp-file 'wrong nil)
+  ;;                   :type 'error)
+  ;;     (should-error (file-watch temp-file '(modify t) nil)
+  ;;                   :type 'error)
+  ;;     (should-error (file-watch temp-file '(modify all-modify) nil)
+  ;;                   :type 'error)
+  ;;     (should-error (file-watch temp-file '(access wrong modify) nil)
+  ;;                   :type 'error)))
+
+  (ert-deftest inotify-file-watch-simple ()
+    "Test if watching a normal file works."
+    (let ((temp-file (make-temp-file "inotify-simple"))
+           (events 0))
+      (let ((wd
+             (inotify-add-watch temp-file t (lambda (ev)
+                                              (setq events (1+ events))))))
+        (unwind-protect
+            (progn
+              (with-temp-file temp-file
+                (insert "Foo\n"))
+              (sit-for 5) ;; Hacky. Wait for 5s until events are processed
+              (should (> events 0)))
+          (inotify-rm-watch wd)))))
+)
+
+(provide 'inotify-tests)
+;;; inotify-tests.el ends here.