auto upstream

25 files changed, 288 insertions, 198 deletions

diff --git a/doc/emacs/ChangeLog b/doc/emacs/ChangeLog
index 83d5b1d25ed..33f530cbadc 100644
--- a/doc/emacs/ChangeLog
+++ b/doc/emacs/ChangeLog
@@ -1,3 +1,8 @@
+2013-02-22  Glenn Morris  <rgm@gnu.org>
+
+        * ack.texi (Acknowledgments):
+        * emacs.texi (Acknowledgments): Small updates.
+
 2013-02-21  Glenn Morris  <rgm@gnu.org>
 
         * files.texi (File Conveniences): Not just GIFs can be animated.
diff --git a/doc/emacs/ack.texi b/doc/emacs/ack.texi
index 718a51c60db..17309f74408 100644
--- a/doc/emacs/ack.texi
+++ b/doc/emacs/ack.texi
@@ -202,7 +202,7 @@ Andrew Choi and Yamamoto Mitsuharu wrote the Carbon support, used
 prior to Emacs 23 for Mac OS.
 
 @item
-Chong Yidong was the Emacs co-maintainer from Emacs 23 onwards.  He made many
+Chong Yidong was the Emacs co-maintainer from Emacs 23 to 24.3.  He made many
 improvements to the Emacs display engine.  He also wrote
 @file{tabulated-list.el}, a generic major mode for lists of data;
 and improved support for themes and packages.
@@ -825,7 +825,7 @@ facility.  He also wrote @code{ebrowse}, the C@t{++} browser;
 and @file{rx.el}, a regular expression constructor.
 
 @item
-Stefan Monnier was the Emacs co-maintainer from Emacs 23 onwards.  He added
+Stefan Monnier was the Emacs (co-)maintainer from Emacs 23 onwards.  He added
 support for Arch and Subversion to VC, re-wrote much of the Emacs server
 to use the built-in networking primitives, and re-wrote the abbrev and
 minibuffer completion code for Emacs 23.  He also wrote @code{PCL-CVS},
diff --git a/doc/emacs/emacs.texi b/doc/emacs/emacs.texi
index 4f11da8032a..bda7c0821c0 100644
--- a/doc/emacs/emacs.texi
+++ b/doc/emacs/emacs.texi
@@ -1375,7 +1375,7 @@ Engster, Hans Henrik Eriksen, Michael Ernst, Ata Etemadi, Frederick
 Farnbach, Oscar Figueiredo, Fred Fish, Steve Fisk, Karl Fogel, Gary
 Foster, Eric S. Fraga, Romain Francoise, Noah Friedman, Andreas
 Fuchs, Shigeru Fukaya, Hallvard Furuseth, Keith Gabryelski, Peter S.
-Galbraith, Kevin Gallagher, Kevin Gallo, Juan León Lahoz García,
+Galbraith, Kevin Gallagher, Fabián E. Gallina, Kevin Gallo, Juan León Lahoz García,
 Howard Gayle, Daniel German, Stephen Gildea, Julien Gilles, David
 Gillespie, Bob Glickstein, Deepak Goel, David De La Harpe Golden, Boris
 Goldowsky, David Goodger, Chris Gray, Kevin Greiner, Michelangelo Grigni, Odd
diff --git a/doc/misc/ChangeLog b/doc/misc/ChangeLog
index 4f827073b2f..9a4f4c10610 100644
--- a/doc/misc/ChangeLog
+++ b/doc/misc/ChangeLog
@@ -1,3 +1,7 @@
+2013-02-22  Glenn Morris  <rgm@gnu.org>
+
+        * flymake.texi (Syntax check statuses): Fix multitable continued rows.
+
 2013-02-21  Paul Eggert  <eggert@cs.ucla.edu>
 
         * Makefile.in (html): New rule.
diff --git a/doc/misc/flymake.texi b/doc/misc/flymake.texi
index 79259a76503..5dedda16ee1 100644
--- a/doc/misc/flymake.texi
+++ b/doc/misc/flymake.texi
@@ -210,14 +210,14 @@ The following statuses are defined.
 @multitable @columnfractions 0.25 0.75
 @item Flymake* or Flymake:E/W*
 @tab  Flymake is currently running. For the second case, E/W contains the
-      error and warning count for the previous run.
+error and warning count for the previous run.
 
 @item Flymake
 @tab  Syntax check is not running. Usually this means syntax check was
-      successfully passed (no errors, no warnings). Other possibilities are:
-      syntax check was killed as a result of executing
-      @code{flymake-compile}, or syntax check cannot start as compilation
-      is currently in progress.
+successfully passed (no errors, no warnings). Other possibilities are:
+syntax check was killed as a result of executing
+@code{flymake-compile}, or syntax check cannot start as compilation
+is currently in progress.
 
 @item Flymake:E/W
 @tab  Number of errors/warnings found by the syntax check process.
@@ -232,9 +232,9 @@ OFF for the buffer.
 @multitable @columnfractions 0.25 0.75
 @item CFGERR
 @tab  Syntax check process returned nonzero exit code, but no
-      errors/warnings were reported. This indicates a possible configuration
-      error (for example, no suitable error message patterns for the
-      syntax check tool).
+errors/warnings were reported. This indicates a possible configuration
+error (for example, no suitable error message patterns for the
+syntax check tool).
 
 @item NOMASTER
 @tab  Flymake was unable to find master file for the current buffer.
diff --git a/etc/DEBUG b/etc/DEBUG
index 6cd0abeeaa5..709e8987d03 100644
--- a/etc/DEBUG
+++ b/etc/DEBUG
@@ -8,17 +8,28 @@ See the end of the file for license conditions.
 read the Windows-specific section near the end of this document.]
 
 ** When you debug Emacs with GDB, you should start it in the directory
-where the executable was made.  That directory has a .gdbinit file
-that defines various "user-defined" commands for debugging Emacs.
-(These commands are described below under "Examining Lisp object
-values" and "Debugging Emacs Redisplay problems".)
-
-** When you are trying to analyze failed assertions, it will be
-essential to compile Emacs either completely without optimizations or
-at least (when using GCC) with the -fno-crossjumping option.  Failure
-to do so may make the compiler recycle the same abort call for all
-assertions in a given function, rendering the stack backtrace useless
-for identifying the specific failed assertion.
+where the executable was made (the 'src' directory in the Emacs source
+tree).  That directory has a .gdbinit file that defines various
+"user-defined" commands for debugging Emacs.  (These commands are
+described below under "Examining Lisp object values" and "Debugging
+Emacs Redisplay problems".)
+
+Some GDB versions by default do not automatically load .gdbinit files
+in the directory where you invoke GDB.  With those versions of GDB,
+you will see a warning when GDB starts, like this:
+
+  warning: File ".../src/.gdbinit" auto-loading has been declined by your `auto-load safe-path' set to "$debugdir:$datadir/auto-load".
+
+There are several ways to overcome that difficulty, they are all
+described in the node "Auto-loading safe path" in the GDB user manual.
+
+** When you are trying to analyze failed assertions or backtraces, it
+will be essential to compile Emacs either completely without
+optimizations (set CFLAGS to "-O0 -g3") or at least (when using GCC)
+with the -fno-crossjumping option in CFLAGS.  Failure to do so may
+make the compiler recycle the same abort call for all assertions in a
+given function, rendering the stack backtrace useless for identifying
+the specific failed assertion.
 
 ** It is a good idea to run Emacs under GDB (or some other suitable
 debugger) *all the time*.  Then, when Emacs crashes, you will be able
diff --git a/lisp/ChangeLog b/lisp/ChangeLog
index 68cff2f6d29..1555dfc43b6 100644
--- a/lisp/ChangeLog
+++ b/lisp/ChangeLog
@@ -1,3 +1,38 @@
+2013-02-22  Juri Linkov  <juri@jurta.org>
+
+        * isearch.el (isearch-lazy-highlight-new-loop):
+        Set `isearch-lazy-highlight-start' and `isearch-lazy-highlight-end'
+        to `isearch-other-end' if it is not nil.  (Bug#13402)
+
+        * replace.el (replace-highlight): Let-bind `isearch-other-end'
+        to `match-beg'.
+
+        * textmodes/ispell.el (ispell-highlight-spelling-error-overlay):
+        Let-bind `isearch-other-end' to `start', `isearch-forward' to t
+        and `isearch-error' to nil.
+
+2013-02-22  Michael Albinus  <michael.albinus@gmx.de>
+
+        * net/tramp.el (tramp-tramp-file-p): Fix docstring.
+
+        * net/tramp-sh.el (tramp-sh-handle-insert-directory): Handle
+        multibyte file names.
+
+2013-02-22  Glenn Morris  <rgm@gnu.org>
+
+        * textmodes/sgml-mode.el (sgml-xml-mode): Move before use.
+        (sgml-transformation-function): Give it a :set function.
+        (sgml-tag): Doc fix.
+
+        * cmuscheme.el (scheme-buffer):
+        * progmodes/inf-lisp.el (inferior-lisp-buffer):
+        * progmodes/tcl.el (inferior-tcl-buffer):
+        * textmodes/tex-mode.el (tex-command): Doc fixes.
+
+        * image-mode.el (image-mode): Add mouse bindings for mode-line-process.
+
+        * htmlfontify.el (hfy-default-header): Encode title string.  (Bug#7457)
+
 2013-02-21  Bastien Guerry  <bzg@gnu.org>
 
         * cmuscheme.el (scheme-buffer): Fix docstring.  (Bug#13778)
diff --git a/lisp/cmuscheme.el b/lisp/cmuscheme.el
index 130eb374538..0f89eae8828 100644
--- a/lisp/cmuscheme.el
+++ b/lisp/cmuscheme.el
@@ -478,8 +478,8 @@ This process selection is performed by function `scheme-proc'.
 
 Whenever \\[run-scheme] fires up a new process, it resets `scheme-buffer'
 to be the new process's buffer.  If you only run one process, this will
-do the right thing.  If you run multiple processes, you can change
-`scheme-buffer' to another process buffer with \\[set-variable].
+do the right thing.  If you run multiple processes, you might need to
+set `scheme-buffer' to whichever process buffer you want to use.
 
 More sophisticated approaches are, of course, possible.  If you find yourself
 needing to switch back and forth between multiple processes frequently,
diff --git a/lisp/gnus/ChangeLog b/lisp/gnus/ChangeLog
index 8de9e89a23d..6642a2082c7 100644
--- a/lisp/gnus/ChangeLog
+++ b/lisp/gnus/ChangeLog
@@ -1,3 +1,10 @@
+2013-02-22  David Engster  <deng@randomsample.de>
+
+        * gnus-registry.el (gnus-registry-save): Provide class name when
+        calling `eieio-persistent-read' to avoid "unsafe call" warning.  Use
+        `condition-case' to stay compatible with older EIEIO versions which
+        only accept one argument.
+
 2013-02-17  Daiki Ueno  <ueno@gnu.org>
 
         * mml2015.el (epg-key-user-id-list, epg-user-id-string)
diff --git a/lisp/gnus/gnus-registry.el b/lisp/gnus/gnus-registry.el
index e808b1975b4..d4764c08fde 100644
--- a/lisp/gnus/gnus-registry.el
+++ b/lisp/gnus/gnus-registry.el
@@ -296,8 +296,14 @@ This is not required after changing `gnus-registry-cache-file'."
     (condition-case nil
         (progn
           (gnus-message 5 "Reading Gnus registry from %s..." file)
-          (setq gnus-registry-db (gnus-registry-fixup-registry
-                                  (eieio-persistent-read file)))
+          (setq gnus-registry-db
+                (gnus-registry-fixup-registry
+                 (condition-case nil
+                     (with-no-warnings
+                       (eieio-persistent-read file 'registry-db))
+                   ;; Older EIEIO versions do not check the class name.
+                   ('wrong-number-of-arguments
+                    (eieio-persistent-read file)))))
           (gnus-message 5 "Reading Gnus registry from %s...done" file))
       (error
        (gnus-message
diff --git a/lisp/htmlfontify.el b/lisp/htmlfontify.el
index df8ef86a3cd..768dda993e2 100644
--- a/lisp/htmlfontify.el
+++ b/lisp/htmlfontify.el
@@ -717,7 +717,7 @@ STYLE is the inline CSS stylesheet (or tag referring to an external sheet)."
 --> </script>
   </head>
   <body onload=\"stripe('index'); return true;\">\n"
-          file style))
+          (mapconcat 'hfy-html-quote (mapcar 'char-to-string file) "") style))
 
 (defun hfy-default-footer (_file)
   "Default value for `hfy-page-footer'.
diff --git a/lisp/image-mode.el b/lisp/image-mode.el
index 6ae1bb20cdc..ac090f020b3 100644
--- a/lisp/image-mode.el
+++ b/lisp/image-mode.el
@@ -476,11 +476,22 @@ to toggle between display as an image and display as text."
            ((setq animated (image-multi-frame-p image))
             (setq image-multi-frame t
                   mode-line-process
-                  `(:eval (propertize
-                           (format " [%s/%s]"
-                                   (1+ (image-current-frame ',image))
-                                   ,(car animated))
-                           'help-echo "Frame number")))
+                  `(:eval
+                    (concat " "
+                            (propertize
+                             (format "[%s/%s]"
+                                     (1+ (image-current-frame ',image))
+                                     ,(car animated))
+                             'help-echo "Frames
+mouse-1: Next frame
+mouse-3: Previous frame"
+                             'mouse-face 'mode-line-highlight
+                             'local-map
+                             '(keymap
+                               (mode-line
+                                keymap
+                                (down-mouse-1 . image-next-frame)
+                                (down-mouse-3 . image-previous-frame)))))))
             (message "%s"
                      (concat msg1 "text.  This image has multiple frames.")))
 ;;;                          (substitute-command-keys
diff --git a/lisp/isearch.el b/lisp/isearch.el
index 31b1918429f..b36b250738a 100644
--- a/lisp/isearch.el
+++ b/lisp/isearch.el
@@ -2961,8 +2961,15 @@ by other Emacs features."
     (setq isearch-lazy-highlight-window       (selected-window)
           isearch-lazy-highlight-window-start (window-start)
           isearch-lazy-highlight-window-end   (window-end)
-          isearch-lazy-highlight-start        (point)
-          isearch-lazy-highlight-end          (point)
+          ;; Start lazy-highlighting at the beginning of the found
+          ;; match (`isearch-other-end').  If no match, use point.
+          ;; One of the next two variables (depending on search direction)
+          ;; is used to define the starting position of lazy-highlighting
+          ;; and also to remember the current position of point between
+          ;; calls of `isearch-lazy-highlight-update', and another variable
+          ;; is used to define where the wrapped search must stop.
+          isearch-lazy-highlight-start        (or isearch-other-end (point))
+          isearch-lazy-highlight-end          (or isearch-other-end (point))
           isearch-lazy-highlight-wrapped      nil
           isearch-lazy-highlight-last-string  isearch-string
           isearch-lazy-highlight-case-fold-search isearch-case-fold-search
@@ -3060,6 +3067,9 @@ Attempt to do the search exactly the way the pending Isearch would."
                           (overlay-put ov 'priority 1000)
                           (overlay-put ov 'face lazy-highlight-face)
                           (overlay-put ov 'window (selected-window))))
+                      ;; Remember the current position of point for
+                      ;; the next call of `isearch-lazy-highlight-update'
+                      ;; when `lazy-highlight-max-at-a-time' is too small.
                       (if isearch-lazy-highlight-forward
                           (setq isearch-lazy-highlight-end (point))
                         (setq isearch-lazy-highlight-start (point)))))
diff --git a/lisp/net/tramp-sh.el b/lisp/net/tramp-sh.el
index 82cbda57086..f2dc514116a 100644
--- a/lisp/net/tramp-sh.el
+++ b/lisp/net/tramp-sh.el
@@ -2606,10 +2606,13 @@ This is like `dired-recursive-delete-directory' for Tramp files."
        (if full-directory-p "yes" "no"))
       ;; If `full-directory-p', we just say `ls -l FILENAME'.
       ;; Else we chdir to the parent directory, then say `ls -ld BASENAME'.
+      ;; "--dired" returns byte positions.  Therefore, the file names
+      ;; must be encoded, which is guaranteed by "LC_ALL=en_US.UTF8
+      ;; LC_CTYPE=''".
       (if full-directory-p
           (tramp-send-command
            v
-           (format "%s %s %s 2>/dev/null"
+           (format "env LC_ALL=en_US.UTF8 LC_CTYPE='' %s %s %s 2>/dev/null"
                    (tramp-get-ls-command v)
                    switches
                    (if wildcard
@@ -2625,7 +2628,7 @@ This is like `dired-recursive-delete-directory' for Tramp files."
           (tramp-run-real-handler 'file-name-directory (list localname))))
         (tramp-send-command
          v
-         (format "%s %s %s"
+         (format "env LC_ALL=en_US.UTF8 LC_CTYPE='' %s %s %s"
                  (tramp-get-ls-command v)
                  switches
                  (if (or wildcard
@@ -2671,6 +2674,11 @@ This is like `dired-recursive-delete-directory' for Tramp files."
           (while (re-search-forward tramp-color-escape-sequence-regexp nil t)
             (replace-match "")))
 
+        ;; Decode the output, it could be multibyte.
+        (decode-coding-region
+         beg (point-max)
+         (or file-name-coding-system default-file-name-coding-system))
+
         ;; The inserted file could be from somewhere else.
         (when (and (not wildcard) (not full-directory-p))
           (goto-char (point-max))
diff --git a/lisp/net/tramp.el b/lisp/net/tramp.el
index 4bfe541f053..fe4959715d5 100644
--- a/lisp/net/tramp.el
+++ b/lisp/net/tramp.el
@@ -1166,11 +1166,9 @@ If the `tramp-methods' entry does not exist, return nil."
 
 ;;;###tramp-autoload
 (defun tramp-tramp-file-p (name)
-  "Return t if NAME is a string with Tramp file name syntax.
-It checks also, whether NAME is unibyte encoded."
+  "Return t if NAME is a string with Tramp file name syntax."
   (save-match-data
     (and (stringp name)
-;        (string-equal name (string-as-unibyte name))
          (string-match tramp-file-name-regexp name))))
 
 (defun tramp-find-method (method user host)
@@ -1354,7 +1352,7 @@ The outline level is equal to the verbosity of the Tramp message."
       (get-buffer-create (tramp-debug-buffer-name vec))
     (when (bobp)
       (setq buffer-undo-list t)
-      ;; So it does not get loaded while outline-regexp is let-bound.
+      ;; So it does not get loaded while `outline-regexp' is let-bound.
       (require 'outline)
       ;; Activate `outline-mode'.  This runs `text-mode-hook' and
       ;; `outline-mode-hook'.  We must prevent that local processes
diff --git a/lisp/progmodes/inf-lisp.el b/lisp/progmodes/inf-lisp.el
index 069f5a32a9e..d73e9489d7c 100644
--- a/lisp/progmodes/inf-lisp.el
+++ b/lisp/progmodes/inf-lisp.el
@@ -201,8 +201,8 @@ This process selection is performed by function `inferior-lisp-proc'.
 Whenever \\[inferior-lisp] fires up a new process, it resets
 `inferior-lisp-buffer' to be the new process's buffer.  If you only run
 one process, this does the right thing.  If you run multiple
-processes, you can change `inferior-lisp-buffer' to another process
-buffer with \\[set-variable].")
+processes, you might need to change `inferior-lisp-buffer' to
+whichever process buffer you want to use.")
 
 (defvar inferior-lisp-mode-hook '()
   "Hook for customizing Inferior Lisp mode.")
diff --git a/lisp/progmodes/tcl.el b/lisp/progmodes/tcl.el
index a32cd969757..9169a433015 100644
--- a/lisp/progmodes/tcl.el
+++ b/lisp/progmodes/tcl.el
@@ -332,8 +332,8 @@ This process selection is performed by function `inferior-tcl-proc'.
 Whenever \\[inferior-tcl] fires up a new process, it resets
 `inferior-tcl-buffer' to be the new process's buffer.  If you only run
 one process, this does the right thing.  If you run multiple
-processes, you can change `inferior-tcl-buffer' to another process
-buffer with \\[set-variable].")
+processes, you might need to set `inferior-tcl-buffer' to
+whichever process buffer you want to use.")
 
 ;;
 ;; Hooks and other customization.
diff --git a/lisp/replace.el b/lisp/replace.el
index 0b8aaa7d349..7f9ea869333 100644
--- a/lisp/replace.el
+++ b/lisp/replace.el
@@ -2203,6 +2203,7 @@ make, or the user didn't cancel the call."
              replace-regexp-lax-whitespace)
             (isearch-case-fold-search case-fold-search)
             (isearch-forward t)
+            (isearch-other-end match-beg)
             (isearch-error nil))
         (isearch-lazy-highlight-new-loop range-beg range-end))))
 
diff --git a/lisp/textmodes/ispell.el b/lisp/textmodes/ispell.el
index dbcf3910db8..50a10dba9a2 100644
--- a/lisp/textmodes/ispell.el
+++ b/lisp/textmodes/ispell.el
@@ -2602,7 +2602,10 @@ The variable `ispell-highlight-face' selects the face to use for highlighting."
                   (regexp-quote (buffer-substring-no-properties start end))
                   "\\b"))
                 (isearch-regexp t)
-                (isearch-case-fold-search nil))
+                (isearch-case-fold-search nil)
+                (isearch-forward t)
+                (isearch-other-end start)
+                (isearch-error nil))
             (isearch-lazy-highlight-new-loop
              (if (boundp 'reg-start) reg-start)
              (if (boundp 'reg-end)   reg-end)))
diff --git a/lisp/textmodes/sgml-mode.el b/lisp/textmodes/sgml-mode.el
index b7288772034..fb0dc84b0e1 100644
--- a/lisp/textmodes/sgml-mode.el
+++ b/lisp/textmodes/sgml-mode.el
@@ -46,9 +46,26 @@
   :type 'integer
   :group 'sgml)
 
+(defcustom sgml-xml-mode nil
+  "When non-nil, tag insertion functions will be XML-compliant.
+It is set to be buffer-local when the file has
+a DOCTYPE or an XML declaration."
+  :type 'boolean
+  :version "22.1"
+  :group 'sgml)
+
 (defcustom sgml-transformation-function 'identity
   "Default value for `skeleton-transformation-function' in SGML mode."
   :type 'function
+  :initialize 'custom-initialize-default
+  :set (lambda (sym val)
+         (set-default sym val)
+         (mapc (lambda (buff)
+                 (with-current-buffer buff
+                   (and (derived-mode-p 'sgml-mode)
+                        (not sgml-xml-mode)
+                        (setq skeleton-transformation-function val))))
+               (buffer-list)))
   :group 'sgml)
 
 (put 'sgml-transformation-function 'variable-interactive
@@ -364,14 +381,6 @@ an optional alist of possible values."
                        (string :tag "Description")))
   :group 'sgml)
 
-(defcustom sgml-xml-mode nil
-  "When non-nil, tag insertion functions will be XML-compliant.
-It is set to be buffer-local when the file has
-a DOCTYPE or an XML declaration."
-  :type 'boolean
-  :version "22.1"
-  :group 'sgml)
-
 (defvar sgml-empty-tags nil
   "List of tags whose !ELEMENT definition says EMPTY.")
 
@@ -635,10 +644,8 @@ This only works for Latin-1 input."
 (define-skeleton sgml-tag
   "Prompt for a tag and insert it, optionally with attributes.
 Completion and configuration are done according to `sgml-tag-alist'.
-If you like tags and attributes in uppercase do \\[set-variable]
-`skeleton-transformation-function' RET `upcase' RET, or put this
-in your `.emacs':
-  (setq sgml-transformation-function 'upcase)"
+If you like tags and attributes in uppercase, customize
+`sgml-transformation-function' to 'upcase."
   (funcall (or skeleton-transformation-function 'identity)
            (setq sgml-tag-last
                  (completing-read
diff --git a/lisp/textmodes/tex-mode.el b/lisp/textmodes/tex-mode.el
index 480ab8a581a..7b16262233d 100644
--- a/lisp/textmodes/tex-mode.el
+++ b/lisp/textmodes/tex-mode.el
@@ -271,9 +271,7 @@ otherwise the value of `tex-start-options', the \(shell-quoted\)
 value of `tex-start-commands', and the file name are added at the end
 with blanks as separators.
 
-In TeX, LaTeX, and SliTeX Mode this variable becomes buffer local.
-In these modes, use \\[set-variable] if you want to change it for the
-current buffer.")
+In TeX, LaTeX, and SliTeX Mode this variable becomes buffer local.")
 
 (defvar tex-trailer nil
   "String appended after the end of a region sent to TeX by \\[tex-region].")
diff --git a/src/ChangeLog b/src/ChangeLog
index ff45c4b2a83..cc8cb84831a 100644
--- a/src/ChangeLog
+++ b/src/ChangeLog
@@ -1,3 +1,16 @@
+2013-02-22  Paul Eggert  <eggert@cs.ucla.edu>
+
+        Assume C89 or better.
+        * ralloc.c (SIZE, POINTER, NIL):
+        * vm-limit.c (POINTER):
+        Remove, replacing all uses with C89 equivalents.  These old
+        symbols were present only for porting to pre-C89 platforms.
+
+2013-02-22  Claudio Bley  <claudio.bley@gmail.com>
+
+        * w32.c (emacs_gnutls_pull): Don't call 'select', and don't loop.
+        This avoids warning messages reported as part of Bug#13546.
+
 2013-02-21  Ken Brown  <kbrown@cornell.edu>
 
         * sheap.c (report_sheap_usage): Fix arguments of message1_no_log.
diff --git a/src/ralloc.c b/src/ralloc.c
index ec1ac40414c..13fd65cbb0c 100644
--- a/src/ralloc.c
+++ b/src/ralloc.c
@@ -52,10 +52,6 @@ extern size_t __malloc_extra_blocks;
 
 #include "getpagesize.h"
 
-typedef size_t SIZE;
-typedef void *POINTER;
-#define NIL ((POINTER) 0)
-
 /* A flag to indicate whether we have initialized ralloc yet.  For
    Emacs's sake, please do not make this local to malloc_init; on some
    machines, the dumping procedure makes all static variables
@@ -72,14 +68,14 @@ static void r_alloc_init (void);
 /* Declarations for working with the malloc, ralloc, and system breaks.  */
 
 /* Function to set the real break value.  */
-POINTER (*real_morecore) (ptrdiff_t);
+void *(*real_morecore) (ptrdiff_t);
 
 /* The break value, as seen by malloc.  */
-static POINTER virtual_break_value;
+static void *virtual_break_value;
 
 /* The address of the end of the last data in use by ralloc,
    including relocatable blocs as well as malloc data.  */
-static POINTER break_value;
+static void *break_value;
 
 /* This is the size of a page.  We round memory requests to this boundary.  */
 static int page_size;
@@ -92,17 +88,17 @@ static int extra_bytes;
    by changing the definition of PAGE.  */
 #define PAGE (getpagesize ())
 #define ROUNDUP(size) (((size_t) (size) + page_size - 1) \
-                       & ~((size_t)(page_size - 1)))
+                       & ~((size_t) (page_size - 1)))
 
 #define MEM_ALIGN sizeof (double)
-#define MEM_ROUNDUP(addr) (((size_t)(addr) + MEM_ALIGN - 1) \
+#define MEM_ROUNDUP(addr) (((size_t) (addr) + MEM_ALIGN - 1) \
                            & ~(MEM_ALIGN - 1))
 
 /* The hook `malloc' uses for the function which gets more space
    from the system.  */
 
 #ifndef SYSTEM_MALLOC
-extern POINTER (*__morecore) (ptrdiff_t);
+extern void *(*__morecore) (ptrdiff_t);
 #endif
 
 
@@ -131,13 +127,13 @@ typedef struct heap
   struct heap *next;
   struct heap *prev;
   /* Start of memory range of this heap.  */
-  POINTER start;
+  void *start;
   /* End of memory range of this heap.  */
-  POINTER end;
+  void *end;
   /* Start of relocatable data in this heap.  */
-  POINTER bloc_start;
+  void *bloc_start;
   /* Start of unused space in this heap.  */
-  POINTER free;
+  void *free;
   /* First bloc in this heap.  */
   struct bp *first_bloc;
   /* Last bloc in this heap.  */
@@ -159,7 +155,7 @@ static heap_ptr first_heap, last_heap;
    The data blocks abut each other; if b->next is non-nil, then
    b->data + b->size == b->next->data.
 
-   An element with variable==NIL denotes a freed block, which has not yet
+   An element with variable==NULL denotes a freed block, which has not yet
    been collected.  They may only appear while r_alloc_freeze_level > 0,
    and will be freed when the arena is thawed.  Currently, these blocs are
    not reusable, while the arena is frozen.  Very inefficient.  */
@@ -168,10 +164,10 @@ typedef struct bp
 {
   struct bp *next;
   struct bp *prev;
-  POINTER *variable;
-  POINTER data;
-  SIZE size;
-  POINTER new_data;             /* temporarily used for relocation */
+  void **variable;
+  void *data;
+  size_t size;
+  void *new_data;               /* temporarily used for relocation */
   struct heap *heap;            /* Heap this bloc is in.  */
 } *bloc_ptr;
 
@@ -192,7 +188,7 @@ static int r_alloc_freeze_level;
 /* Find the heap that ADDRESS falls within.  */
 
 static heap_ptr
-find_heap (POINTER address)
+find_heap (void *address)
 {
   heap_ptr heap;
 
@@ -223,11 +219,11 @@ find_heap (POINTER address)
    Return the address of the space if all went well, or zero if we couldn't
    allocate the memory.  */
 
-static POINTER
-obtain (POINTER address, SIZE size)
+static void *
+obtain (void *address, size_t size)
 {
   heap_ptr heap;
-  SIZE already_available;
+  size_t already_available;
 
   /* Find the heap that ADDRESS falls within.  */
   for (heap = last_heap; heap; heap = heap->prev)
@@ -253,19 +249,19 @@ obtain (POINTER address, SIZE size)
      get more space.  */
   if (heap == NIL_HEAP)
     {
-      POINTER new = (*real_morecore)(0);
-      SIZE get;
+      void *new = real_morecore (0);
+      size_t get;
 
-      already_available = (char *)last_heap->end - (char *)address;
+      already_available = (char *) last_heap->end - (char *) address;
 
       if (new != last_heap->end)
         {
           /* Someone else called sbrk.  Make a new heap.  */
 
           heap_ptr new_heap = (heap_ptr) MEM_ROUNDUP (new);
-          POINTER bloc_start = (POINTER) MEM_ROUNDUP ((POINTER)(new_heap + 1));
+          void *bloc_start = (void *) MEM_ROUNDUP ((void *) (new_heap + 1));
 
-          if ((*real_morecore) ((char *) bloc_start - (char *) new) != new)
+          if (real_morecore ((char *) bloc_start - (char *) new) != new)
             return 0;
 
           new_heap->start = new;
@@ -287,10 +283,10 @@ obtain (POINTER address, SIZE size)
          Get some extra, so we can come here less often.  */
 
       get = size + extra_bytes - already_available;
-      get = (char *) ROUNDUP ((char *)last_heap->end + get)
+      get = (char *) ROUNDUP ((char *) last_heap->end + get)
         - (char *) last_heap->end;
 
-      if ((*real_morecore) (get) != last_heap->end)
+      if (real_morecore (get) != last_heap->end)
         return 0;
 
       last_heap->end = (char *) last_heap->end + get;
@@ -319,13 +315,13 @@ relinquish (void)
                                             ? h->bloc_start : break_value);
     }
 
-  if (excess > extra_bytes * 2 && (*real_morecore) (0) == last_heap->end)
+  if (excess > extra_bytes * 2 && real_morecore (0) == last_heap->end)
     {
       /* Keep extra_bytes worth of empty space.
          And don't free anything unless we can free at least extra_bytes.  */
       excess -= extra_bytes;
 
-      if ((char *)last_heap->end - (char *)last_heap->bloc_start <= excess)
+      if ((char *) last_heap->end - (char *) last_heap->bloc_start <= excess)
         {
           heap_ptr lh_prev;
 
@@ -336,12 +332,12 @@ relinquish (void)
             return;
 
           /* Return the last heap, with its header, to the system.  */
-          excess = (char *)last_heap->end - (char *)last_heap->start;
+          excess = (char *) last_heap->end - (char *) last_heap->start;
           lh_prev = last_heap->prev;
           /* If the system doesn't want that much memory back, leave
              last_heap unaltered to reflect that.  This can occur if
              break_value is still within the original data segment.  */
-          if ((*real_morecore) (- excess) != 0)
+          if (real_morecore (- excess) != 0)
             {
               last_heap = lh_prev;
               last_heap->next = NIL_HEAP;
@@ -349,13 +345,13 @@ relinquish (void)
         }
       else
         {
-          excess = (char *) last_heap->end
-                        - (char *) ROUNDUP ((char *)last_heap->end - excess);
+          excess = ((char *) last_heap->end
+                    - (char *) ROUNDUP ((char *) last_heap->end - excess));
           /* If the system doesn't want that much memory back, leave
              the end of the last heap unchanged to reflect that.  This
              can occur if break_value is still within the original
              data segment.  */
-          if ((*real_morecore) (- excess) != 0)
+          if (real_morecore (- excess) != 0)
             last_heap->end = (char *) last_heap->end - excess;
         }
     }
@@ -367,9 +363,9 @@ relinquish (void)
    to that block.  */
 
 static bloc_ptr
-find_bloc (POINTER *ptr)
+find_bloc (void **ptr)
 {
-  register bloc_ptr p = first_bloc;
+  bloc_ptr p = first_bloc;
 
   while (p != NIL_BLOC)
     {
@@ -392,10 +388,10 @@ find_bloc (POINTER *ptr)
    memory for the new block.  */
 
 static bloc_ptr
-get_bloc (SIZE size)
+get_bloc (size_t size)
 {
-  register bloc_ptr new_bloc;
-  register heap_ptr heap;
+  bloc_ptr new_bloc;
+  heap_ptr heap;
 
   if (! (new_bloc = malloc (BLOC_PTR_SIZE))
       || ! (new_bloc->data = obtain (break_value, size)))
@@ -409,7 +405,7 @@ get_bloc (SIZE size)
 
   new_bloc->size = size;
   new_bloc->next = NIL_BLOC;
-  new_bloc->variable = (POINTER *) NIL;
+  new_bloc->variable = NULL;
   new_bloc->new_data = 0;
 
   /* Record in the heap that this space is in use.  */
@@ -447,9 +443,9 @@ get_bloc (SIZE size)
    Do not touch the contents of blocs or break_value.  */
 
 static int
-relocate_blocs (bloc_ptr bloc, heap_ptr heap, POINTER address)
+relocate_blocs (bloc_ptr bloc, heap_ptr heap, void *address)
 {
-  register bloc_ptr b = bloc;
+  bloc_ptr b = bloc;
 
   /* No need to ever call this if arena is frozen, bug somewhere!  */
   if (r_alloc_freeze_level)
@@ -471,8 +467,8 @@ relocate_blocs (bloc_ptr bloc, heap_ptr heap, POINTER address)
          get enough new space to hold BLOC and all following blocs.  */
       if (heap == NIL_HEAP)
         {
-          register bloc_ptr tb = b;
-          register SIZE s = 0;
+          bloc_ptr tb = b;
+          size_t s = 0;
 
           /* Add up the size of all the following blocs.  */
           while (tb != NIL_BLOC)
@@ -568,12 +564,12 @@ update_heap_bloc_correspondence (bloc_ptr bloc, heap_ptr heap)
    that come after BLOC in memory.  */
 
 static int
-resize_bloc (bloc_ptr bloc, SIZE size)
+resize_bloc (bloc_ptr bloc, size_t size)
 {
-  register bloc_ptr b;
+  bloc_ptr b;
   heap_ptr heap;
-  POINTER address;
-  SIZE old_size;
+  void *address;
+  size_t old_size;
 
   /* No need to ever call this if arena is frozen, bug somewhere!  */
   if (r_alloc_freeze_level)
@@ -675,7 +671,7 @@ free_bloc (bloc_ptr bloc)
 
   if (r_alloc_freeze_level)
     {
-      bloc->variable = (POINTER *) NIL;
+      bloc->variable = NULL;
       return;
     }
 
@@ -752,17 +748,17 @@ free_bloc (bloc_ptr bloc)
    __morecore hook values - in particular, __default_morecore in the
    GNU malloc package.  */
 
-static POINTER
+static void *
 r_alloc_sbrk (ptrdiff_t size)
 {
-  register bloc_ptr b;
-  POINTER address;
+  bloc_ptr b;
+  void *address;
 
   if (! r_alloc_initialized)
     r_alloc_init ();
 
   if (use_relocatable_buffers <= 0)
-    return (*real_morecore) (size);
+    return real_morecore (size);
 
   if (size == 0)
     return virtual_break_value;
@@ -772,19 +768,19 @@ r_alloc_sbrk (ptrdiff_t size)
       /* Allocate a page-aligned space.  GNU malloc would reclaim an
          extra space if we passed an unaligned one.  But we could
          not always find a space which is contiguous to the previous.  */
-      POINTER new_bloc_start;
+      void *new_bloc_start;
       heap_ptr h = first_heap;
-      SIZE get = ROUNDUP (size);
+      size_t get = ROUNDUP (size);
 
-      address = (POINTER) ROUNDUP (virtual_break_value);
+      address = (void *) ROUNDUP (virtual_break_value);
 
       /* Search the list upward for a heap which is large enough.  */
-      while ((char *) h->end < (char *) MEM_ROUNDUP ((char *)address + get))
+      while ((char *) h->end < (char *) MEM_ROUNDUP ((char *) address + get))
         {
           h = h->next;
           if (h == NIL_HEAP)
             break;
-          address = (POINTER) ROUNDUP (h->start);
+          address = (void *) ROUNDUP (h->start);
         }
 
       /* If not found, obtain more space.  */
@@ -796,19 +792,19 @@ r_alloc_sbrk (ptrdiff_t size)
             return 0;
 
           if (first_heap == last_heap)
-            address = (POINTER) ROUNDUP (virtual_break_value);
+            address = (void *) ROUNDUP (virtual_break_value);
           else
-            address = (POINTER) ROUNDUP (last_heap->start);
+            address = (void *) ROUNDUP (last_heap->start);
           h = last_heap;
         }
 
-      new_bloc_start = (POINTER) MEM_ROUNDUP ((char *)address + get);
+      new_bloc_start = (void *) MEM_ROUNDUP ((char *) address + get);
 
       if (first_heap->bloc_start < new_bloc_start)
         {
           /* This is no clean solution - no idea how to do it better.  */
           if (r_alloc_freeze_level)
-            return NIL;
+            return NULL;
 
           /* There is a bug here: if the above obtain call succeeded, but the
              relocate_blocs call below does not succeed, we need to free
@@ -818,7 +814,7 @@ r_alloc_sbrk (ptrdiff_t size)
           if (! relocate_blocs (first_bloc, h, new_bloc_start))
             return 0;
 
-          /* Note that (POINTER)(h+1) <= new_bloc_start since
+          /* Note that (char *) (h + 1) <= (char *) new_bloc_start since
              get >= page_size, so the following does not destroy the heap
              header.  */
           for (b = last_bloc; b != NIL_BLOC; b = b->prev)
@@ -855,8 +851,8 @@ r_alloc_sbrk (ptrdiff_t size)
     }
   else /* size < 0 */
     {
-      SIZE excess = (char *)first_heap->bloc_start
-                      - ((char *)virtual_break_value + size);
+      size_t excess = ((char *) first_heap->bloc_start
+                       - ((char *) virtual_break_value + size));
 
       address = virtual_break_value;
 
@@ -864,7 +860,7 @@ r_alloc_sbrk (ptrdiff_t size)
         {
           excess -= extra_bytes;
           first_heap->bloc_start
-            = (POINTER) MEM_ROUNDUP ((char *)first_heap->bloc_start - excess);
+            = (void *) MEM_ROUNDUP ((char *) first_heap->bloc_start - excess);
 
           relocate_blocs (first_bloc, first_heap, first_heap->bloc_start);
 
@@ -876,14 +872,14 @@ r_alloc_sbrk (ptrdiff_t size)
             }
         }
 
-      if ((char *)virtual_break_value + size < (char *)first_heap->start)
+      if ((char *) virtual_break_value + size < (char *) first_heap->start)
         {
           /* We found an additional space below the first heap */
-          first_heap->start = (POINTER) ((char *)virtual_break_value + size);
+          first_heap->start = (void *) ((char *) virtual_break_value + size);
         }
     }
 
-  virtual_break_value = (POINTER) ((char *)address + size);
+  virtual_break_value = (void *) ((char *) address + size);
   break_value = (last_bloc
                  ? (char *) last_bloc->data + last_bloc->size
                  : (char *) first_heap->bloc_start);
@@ -905,10 +901,10 @@ r_alloc_sbrk (ptrdiff_t size)
    If we can't allocate the necessary memory, set *PTR to zero, and
    return zero.  */
 
-POINTER
-r_alloc (POINTER *ptr, SIZE size)
+void *
+r_alloc (void **ptr, size_t size)
 {
-  register bloc_ptr new_bloc;
+  bloc_ptr new_bloc;
 
   if (! r_alloc_initialized)
     r_alloc_init ();
@@ -929,9 +925,9 @@ r_alloc (POINTER *ptr, SIZE size)
    Store 0 in *PTR to show there's no block allocated.  */
 
 void
-r_alloc_free (register POINTER *ptr)
+r_alloc_free (void **ptr)
 {
-  register bloc_ptr dead_bloc;
+  bloc_ptr dead_bloc;
 
   if (! r_alloc_initialized)
     r_alloc_init ();
@@ -962,10 +958,10 @@ r_alloc_free (register POINTER *ptr)
    If more memory cannot be allocated, then leave *PTR unchanged, and
    return zero.  */
 
-POINTER
-r_re_alloc (POINTER *ptr, SIZE size)
+void *
+r_re_alloc (void **ptr, size_t size)
 {
-  register bloc_ptr bloc;
+  bloc_ptr bloc;
 
   if (! r_alloc_initialized)
     r_alloc_init ();
@@ -1004,15 +1000,15 @@ r_re_alloc (POINTER *ptr, SIZE size)
             {
               new_bloc->variable = ptr;
               *ptr = new_bloc->data;
-              bloc->variable = (POINTER *) NIL;
+              bloc->variable = NULL;
             }
           else
-            return NIL;
+            return NULL;
         }
       else
         {
           if (! resize_bloc (bloc, MEM_ROUNDUP (size)))
-            return NIL;
+            return NULL;
         }
     }
   return *ptr;
@@ -1052,27 +1048,27 @@ r_alloc_check (void)
     return;
 
   assert (first_heap);
-  assert (last_heap->end <= (POINTER) sbrk (0));
-  assert ((POINTER) first_heap < first_heap->start);
+  assert (last_heap->end <= (void *) sbrk (0));
+  assert ((void *) first_heap < first_heap->start);
   assert (first_heap->start <= virtual_break_value);
   assert (virtual_break_value <= first_heap->end);
 
   for (h = first_heap; h; h = h->next)
     {
       assert (h->prev == ph);
-      assert ((POINTER) ROUNDUP (h->end) == h->end);
+      assert ((void *) ROUNDUP (h->end) == h->end);
 #if 0 /* ??? The code in ralloc.c does not really try to ensure
          the heap start has any sort of alignment.
          Perhaps it should.  */
-      assert ((POINTER) MEM_ROUNDUP (h->start) == h->start);
+      assert ((void *) MEM_ROUNDUP (h->start) == h->start);
 #endif
-      assert ((POINTER) MEM_ROUNDUP (h->bloc_start) == h->bloc_start);
+      assert ((void *) MEM_ROUNDUP (h->bloc_start) == h->bloc_start);
       assert (h->start <= h->bloc_start && h->bloc_start <= h->end);
 
       if (ph)
         {
           assert (ph->end < h->start);
-          assert (h->start <= (POINTER)h && (POINTER)(h+1) <= h->bloc_start);
+          assert (h->start <= (void *) h && (void *) (h + 1) <= h->bloc_start);
         }
 
       if (h->bloc_start <= break_value && break_value <= h->end)
@@ -1087,8 +1083,8 @@ r_alloc_check (void)
   for (b = first_bloc; b; b = b->next)
     {
       assert (b->prev == pb);
-      assert ((POINTER) MEM_ROUNDUP (b->data) == b->data);
-      assert ((SIZE) MEM_ROUNDUP (b->size) == b->size);
+      assert ((void *) MEM_ROUNDUP (b->data) == b->data);
+      assert ((size_t) MEM_ROUNDUP (b->size) == b->size);
 
       ph = 0;
       for (h = first_heap; h; h = h->next)
@@ -1137,7 +1133,7 @@ r_alloc_check (void)
    is checked to ensure that memory corruption does not occur due to
    misuse.  */
 void
-r_alloc_reset_variable (POINTER *old, POINTER *new)
+r_alloc_reset_variable (void **old, void **new)
 {
   bloc_ptr bloc = first_bloc;
 
@@ -1192,8 +1188,8 @@ r_alloc_init (void)
   first_heap = last_heap = &heap_base;
   first_heap->next = first_heap->prev = NIL_HEAP;
   first_heap->start = first_heap->bloc_start
-    = virtual_break_value = break_value = (*real_morecore) (0);
-  if (break_value == NIL)
+    = virtual_break_value = break_value = real_morecore (0);
+  if (break_value == NULL)
     emacs_abort ();
 
   extra_bytes = ROUNDUP (50000);
@@ -1218,7 +1214,7 @@ r_alloc_init (void)
 #endif
 
 #ifndef SYSTEM_MALLOC
-  first_heap->end = (POINTER) ROUNDUP (first_heap->start);
+  first_heap->end = (void *) ROUNDUP (first_heap->start);
 
   /* The extra call to real_morecore guarantees that the end of the
      address space is a multiple of page_size, even if page_size is
@@ -1226,7 +1222,7 @@ r_alloc_init (void)
      which page_size is stored.  This allows a binary to be built on a
      system with one page size and run on a system with a smaller page
      size.  */
-  (*real_morecore) ((char *) first_heap->end - (char *) first_heap->start);
+  real_morecore ((char *) first_heap->end - (char *) first_heap->start);
 
   /* Clear the rest of the last page; this memory is in our address space
      even though it is after the sbrk value.  */
diff --git a/src/vm-limit.c b/src/vm-limit.c
index 9dbb1b884b7..fc7a253325a 100644
--- a/src/vm-limit.c
+++ b/src/vm-limit.c
@@ -31,14 +31,12 @@ along with GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.  */
 enum warnlevel { not_warned, warned_75, warned_85, warned_95 };
 static enum warnlevel warnlevel;
 
-typedef void *POINTER;
-
 /* Function to call to issue a warning;
    0 means don't issue them.  */
 static void (*warn_function) (const char *);
 
 /* Start of data space; can be changed by calling malloc_init.  */
-static POINTER data_space_start;
+static void *data_space_start;
 
 /* Number of bytes of writable memory we can expect to be able to get.  */
 static size_t lim_data;
@@ -123,11 +121,11 @@ static void
 check_memory_limits (void)
 {
 #ifdef REL_ALLOC
-  extern POINTER (*real_morecore) (ptrdiff_t);
+  extern void *(*real_morecore) (ptrdiff_t);
 #endif
-  extern POINTER (*__morecore) (ptrdiff_t);
+  extern void *(*__morecore) (ptrdiff_t);
 
-  register POINTER cp;
+  void *cp;
   size_t five_percent;
   size_t data_size;
   enum warnlevel new_warnlevel;
@@ -215,9 +213,9 @@ start_of_data (void)
 {
 #ifdef BSD_SYSTEM
   extern char etext;
-  return (POINTER)(&etext);
+  return (void *) &etext;
 #elif defined DATA_START
-  return ((POINTER) DATA_START);
+  return (void *) DATA_START;
 #elif defined ORDINARY_LINK
   /*
    * This is a hack.  Since we're not linking crt0.c or pre_crt0.c,
@@ -225,10 +223,10 @@ start_of_data (void)
    * is known to live at or near the start of the system crt0.c, and
    * we don't sweat the handful of bytes that might lose.
    */
-  return ((POINTER) &environ);
+  return (void *) &environ;
 #else
   extern int data_start;
-  return ((POINTER) &data_start);
+  return (void *) &data_start;
 #endif
 }
 #endif /* (not CANNOT_DUMP or not SYSTEM_MALLOC) */
@@ -238,7 +236,7 @@ start_of_data (void)
    WARNFUN specifies the function to call to issue a warning.  */
 
 void
-memory_warnings (POINTER start, void (*warnfun) (const char *))
+memory_warnings (void *start, void (*warnfun) (const char *))
 {
   extern void (* __after_morecore_hook) (void);     /* From gmalloc.c */
 
diff --git a/src/w32.c b/src/w32.c
index ed86b1238ae..5011642adf2 100644
--- a/src/w32.c
+++ b/src/w32.c
@@ -7822,47 +7822,26 @@ serial_configure (struct Lisp_Process *p, Lisp_Object contact)
 ssize_t
 emacs_gnutls_pull (gnutls_transport_ptr_t p, void* buf, size_t sz)
 {
-  int n, sc, err;
+  int n, err;
   SELECT_TYPE fdset;
   EMACS_TIME timeout;
   struct Lisp_Process *process = (struct Lisp_Process *)p;
   int fd = process->infd;
 
-  for (;;)
-    {
-      n = sys_read (fd, (char*)buf, sz);
+  n = sys_read (fd, (char*)buf, sz);
 
-      if (n >= 0)
-        return n;
+  if (n >= 0)
+    return n;
 
-      err = errno;
+  err = errno;
 
-      if (err == EWOULDBLOCK)
-        {
-          /* Set a small timeout.  */
-          timeout = make_emacs_time (1, 0);
-          FD_ZERO (&fdset);
-          FD_SET ((int)fd, &fdset);
-
-          /* Use select with the timeout to poll the selector.  */
-          sc = select (fd + 1, &fdset, (SELECT_TYPE *)0, (SELECT_TYPE *)0,
-                       &timeout, NULL);
-
-          if (sc > 0)
-            continue;  /* Try again.  */
-
-          /* Translate the WSAEWOULDBLOCK alias EWOULDBLOCK to EAGAIN.
-             Also accept select return 0 as an indicator to EAGAIN.  */
-          if (sc == 0 || errno == EWOULDBLOCK)
-            err = EAGAIN;
-          else
-            err = errno; /* Other errors are just passed on.  */
-        }
+  /* Translate the WSAEWOULDBLOCK alias EWOULDBLOCK to EAGAIN. */
+  if (err == EWOULDBLOCK)
+    err = EAGAIN;
 
-      emacs_gnutls_transport_set_errno (process->gnutls_state, err);
+  emacs_gnutls_transport_set_errno (process->gnutls_state, err);
 
-      return -1;
-    }
+  return -1;
 }
 
 ssize_t