procyberian/emacs
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Merge branch 'emacs-26' of git.savannah.gnu.org:/srv/git/emacs into emacs-26

Browse source
This commit is contained in:
Eli Zaretskii 2017-09-29 10:02:33 +03:00
commit c1ac8c170f
32 changed files with 1937 additions and 1922 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

15
doc/lispref/buffers.texi
View file

@ -1089,12 +1089,15 @@ is not cleared by changing major modes.
@defopt buffer-offer-save
This variable, if non-@code{nil} in a particular buffer, tells
@code{save-buffers-kill-emacs} and @code{save-some-buffers} (if the
second optional argument to that function is @code{t}) to offer to
save that buffer, just as they offer to save file-visiting buffers.
@xref{Definition of save-some-buffers}. The variable
@code{buffer-offer-save} automatically becomes buffer-local when set
for any reason. @xref{Buffer-Local Variables}.
@code{save-buffers-kill-emacs} to offer to save that buffer, just as
it offers to save file-visiting buffers. If @code{save-some-buffers}
is called with the second optional argument set to @code{t}, it will
also offer to save the buffer. Lastly, if this variable is set to the
symbol @code{always}, both @code{save-buffers-kill-emacs} and
@code{save-some-buffers} will always offer to save. @xref{Definition
of save-some-buffers}. The variable @code{buffer-offer-save}
automatically becomes buffer-local when set for any reason.
@xref{Buffer-Local Variables}.
@end defopt
@defvar buffer-save-without-query

3
doc/lispref/files.texi
View file

@ -368,8 +368,7 @@ With an argument of 0, unconditionally do @emph{not} make any backup file.
This command saves some modified file-visiting buffers. Normally it
asks the user about each buffer. But if @var{save-silently-p} is
non-@code{nil}, it saves all the file-visiting buffers without
querying the user. Additionally, buffers whose name begins with a
space (``internal'' buffers) will not be offered for save.
querying the user.
@vindex save-some-buffers-default-predicate
The optional @var{pred} argument provides a predicate that controls

56
doc/lispref/frames.texi
View file

@ -112,37 +112,39 @@ window of another Emacs frame. @xref{Child Frames}.
* Display Feature Testing:: Determining the features of a terminal.
@end menu
@node Creating Frames
@section Creating Frames
@cindex frame creation
To create a new frame, call the function @code{make-frame}.
@deffn Command make-frame &optional alist
@deffn Command make-frame &optional parameters
This function creates and returns a new frame, displaying the current
buffer.
The @var{alist} argument is an alist that specifies frame parameters
for the new frame. @xref{Frame Parameters}. If you specify the
@code{terminal} parameter in @var{alist}, the new frame is created on
that terminal. Otherwise, if you specify the @code{window-system}
frame parameter in @var{alist}, that determines whether the frame
should be displayed on a text terminal or a graphical terminal.
@xref{Window Systems}. If neither is specified, the new frame is
created in the same terminal as the selected frame.
The @var{parameters} argument is an alist that specifies frame
parameters for the new frame. @xref{Frame Parameters}. If you specify
the @code{terminal} parameter in @var{parameters}, the new frame is
created on that terminal. Otherwise, if you specify the
@code{window-system} frame parameter in @var{parameters}, that
determines whether the frame should be displayed on a text terminal or a
graphical terminal. @xref{Window Systems}. If neither is specified,
the new frame is created in the same terminal as the selected frame.
Any parameters not mentioned in @var{alist} default to the values in
the alist @code{default-frame-alist} (@pxref{Initial Parameters});
Any parameters not mentioned in @var{parameters} default to the values
in the alist @code{default-frame-alist} (@pxref{Initial Parameters});
parameters not specified there default from the X resources or its
equivalent on your operating system (@pxref{X Resources,, X Resources,
emacs, The GNU Emacs Manual}). After the frame is created, Emacs
applies any parameters listed in @code{frame-inherited-parameters}
(see below) and not present in the argument, taking the values from
the frame that was selected when @code{make-frame} was called.
emacs, The GNU Emacs Manual}). After the frame is created, this
function applies any parameters specified in
@code{frame-inherited-parameters} (see below) it has no assigned yet,
taking the values from the frame that was selected when
@code{make-frame} was called.
Note that on multi-monitor displays (@pxref{Multiple Terminals}), the
window manager might position the frame differently than specified by
the positional parameters in @var{alist} (@pxref{Position
the positional parameters in @var{parameters} (@pxref{Position
Parameters}). For example, some window managers have a policy of
displaying the frame on the monitor that contains the largest part of
the window (a.k.a.@: the @dfn{dominating} monitor).
@ -158,20 +160,28 @@ A normal hook run by @code{make-frame} before it creates the frame.
@end defvar
@defvar after-make-frame-functions
An abnormal hook run by @code{make-frame} after it creates the frame.
Each function in @code{after-make-frame-functions} receives one argument, the
frame just created.
An abnormal hook run by @code{make-frame} after it created the frame.
Each function in @code{after-make-frame-functions} receives one
argument, the frame just created.
@end defvar
Note that any functions added to these hooks by your initial file are
usually not run for the initial frame, since Emacs reads the initial
file only after creating that frame. However, if the initial frame is
specified to use a separate minibuffer frame (@pxref{Minibuffers and
Frames}), the functions will be run for both, the minibuffer-less and
the minibuffer frame.
@defvar frame-inherited-parameters
This variable specifies the list of frame parameters that a newly
created frame inherits from the currently selected frame. For each
parameter (a symbol) that is an element in the list and is not present
in the argument to @code{make-frame}, the function sets the value of
that parameter in the created frame to its value in the selected
frame.
parameter (a symbol) that is an element in this list and has not been
assigned earlier when processing @code{make-frame}, the function sets
the value of that parameter in the created frame to its value in the
selected frame.
@end defvar
@node Multiple Terminals
@section Multiple Terminals
@cindex multiple terminals

24
doc/lispref/text.texi
View file

@ -54,6 +54,8 @@ the character after point.
* Registers:: How registers are implemented. Accessing the text or
position stored in a register.
* Transposition:: Swapping two portions of a buffer.
* Replacing:: Replacing the text of one buffer with the text
of another buffer.
* Decompression:: Dealing with compressed data.
* Base 64:: Conversion to or from base 64 encoding.
* Checksum/Hash:: Computing cryptographic hashes.
@ -4328,6 +4330,28 @@ is non-@code{nil}, @code{transpose-regions} does not do this---it leaves
all markers unrelocated.
@end defun
@node Replacing
@section Replacing Buffer Text
You can use the following function to replace the text of one buffer
with the text of another buffer:
@deffn Command replace-buffer-contents source
This function replaces the accessible portion of the current buffer
with the accessible portion of the buffer @var{source}. @var{source}
may either be a buffer object or the name of a buffer. When
@code{replace-buffer-contents} succeeds, the text of the accessible
portion of the current buffer will be equal to the text of the
accessible portion of the @var{source} buffer. This function attempts
to keep point, markers, text properties, and overlays in the current
buffer intact. One potential case where this behavior is useful is
external code formatting programs: they typically write the
reformatted text into a temporary buffer or file, and using
@code{delete-region} and @code{insert-buffer-substring} would destroy
these properties. However, the latter combination is typically
faster. @xref{Deletion}, and @ref{Insertion}.
@end deffn
@node Decompression
@section Dealing With Compressed Data

21
etc/NEWS
View file

@ -117,6 +117,11 @@ The effect is similar to that of "toolBar" resource on the tool bar.
* Changes in Emacs 26.1
+++
** Option 'buffer-offer-save' can be set to new value, 'always'. When
set to 'always', the command `save-some-buffers' will always offer
this buffer for saving.
** Security vulnerability related to Enriched Text mode is removed.
+++
@ -144,8 +149,7 @@ init file:
'save-buffer' process. Previously, saving a buffer that was not
visiting a file would always prompt for a file name. Now it only does
so if 'write-contents-functions' is nil (or all its functions return
nil). A non-nil buffer-local value for this variable is sufficient
for 'save-some-buffers' to consider the buffer for saving.
nil).
---
** New variable 'executable-prefix-env' for inserting magic signatures.
@ -578,7 +582,6 @@ Negative prefix arg flips the direction of selection. Also,
defun are selected unless they are separated from the defun by a blank
line.
---
** New command 'replace-buffer-contents'.
This command replaces the contents of the accessible portion of the
current buffer with the contents of the accessible portion of a
@ -1350,6 +1353,12 @@ non-nil, but the code returned the list in the increasing order of
priority instead. Now the code does what the documentation says it
should do.
---
** 'eldoc-message' only accepts one argument now. Programs that
called it with multiple arguments before should pass them through
'format' first. Even that is discouraged: for ElDoc support, you
should set 'eldoc-documentation-function' instead of calling
'eldoc-message' directly.
* Lisp Changes in Emacs 26.1
@ -1891,9 +1900,9 @@ of frame decorations on macOS 10.9+.
---
** Mousewheel and trackpad scrolling on macOS 10.7+ now behaves more
like the macOS default. The new variables
'ns-use-system-mwheel-acceleration', 'ns-touchpad-scroll-line-height'
and 'ns-touchpad-use-momentum' can be used to customize the behavior.
like the macOS default. The new variables 'ns-mwheel-line-height',
'ns-use-mwheel-acceleration' and 'ns-use-mwheel-momentum' can be used
to customize the behavior.
----------------------------------------------------------------------

5
lisp/emacs-lisp/ert.el
View file

@ -742,9 +742,8 @@ run. ARGS are the arguments to `debugger'."
;; backtrace ready for printing is important for batch
;; use.
;;
;; Grab the frames starting from `signal', frames below
;; that are all from the debugger.
(backtrace (backtrace-frames 'signal))
;; Grab the frames above the debugger.
(backtrace (cdr (backtrace-frames debugger)))
(infos (reverse ert--infos)))
(setf (ert--test-execution-info-result info)
(cl-ecase type

4
lisp/emacs-lisp/smie.el
View file

@ -1956,7 +1956,7 @@ E.g. provided via a file-local call to `smie-config-local'.")
(defvar smie-config--modefuns nil)
(defun smie-config--setter (var value)
(setq-default var value)
(set-default var value)
(let ((old-modefuns smie-config--modefuns))
(setq smie-config--modefuns nil)
(pcase-dolist (`(,mode . ,rules) value)
@ -1982,7 +1982,7 @@ value with which to replace it."
;; FIXME improve value-type.
:type '(choice (const nil)
(alist :key-type symbol))
:initialize 'custom-initialize-default
:initialize 'custom-initialize-set
:set #'smie-config--setter)
(defun smie-config-local (rules)

85
lisp/emacs-lisp/syntax.el
View file

@ -381,10 +381,26 @@ This function should move the cursor back to some syntactically safe
point (where the PPSS is equivalent to nil).")
(make-obsolete-variable 'syntax-begin-function nil "25.1")
(defvar-local syntax-ppss-cache nil
"List of (POS . PPSS) pairs, in decreasing POS order.")
(defvar-local syntax-ppss-last nil
"Cache of (LAST-POS . LAST-PPSS).")
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; Several caches.
;;
;; Because `syntax-ppss' is equivalent to (parse-partial-sexp
;; (POINT-MIN) x), we need either to empty the cache when we narrow
;; the buffer, which is suboptimal, or we need to use several caches.
;; We use two of them, one for widened buffer, and one for narrowing.
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
(defvar-local syntax-ppss-wide nil
"Cons of two elements (LAST . CACHE).
Where LAST is a pair (LAST-POS . LAST-PPS) caching the last invocation
and CACHE is a list of (POS . PPSS) pairs, in decreasing POS order.
These are valid when the buffer has no restriction.")
(defvar-local syntax-ppss-narrow nil
"Same as `syntax-ppss-wide' but for a narrowed buffer.")
(defvar-local syntax-ppss-narrow-start nil
"Start position of the narrowing for `syntax-ppss-narrow'.")
(defalias 'syntax-ppss-after-change-function 'syntax-ppss-flush-cache)
(defun syntax-ppss-flush-cache (beg &rest ignored)
@ -392,24 +408,29 @@ point (where the PPSS is equivalent to nil).")
;; Set syntax-propertize to refontify anything past beg.
(setq syntax-propertize--done (min beg syntax-propertize--done))
;; Flush invalid cache entries.
(while (and syntax-ppss-cache (> (caar syntax-ppss-cache) beg))
(setq syntax-ppss-cache (cdr syntax-ppss-cache)))
(dolist (cell (list syntax-ppss-wide syntax-ppss-narrow))
(pcase cell
(`(,last . ,cache)
(while (and cache (> (caar cache) beg))
(setq cache (cdr cache)))
;; Throw away `last' value if made invalid.
(when (< beg (or (car syntax-ppss-last) 0))
(when (< beg (or (car last) 0))
;; If syntax-begin-function jumped to BEG, then the old state at BEG can
;; depend on the text after BEG (which is presumably changed). So if
;; BEG=(car (nth 10 syntax-ppss-last)) don't reuse that data because the
;; assumed nil state at BEG may not be valid any more.
(if (<= beg (or (syntax-ppss-toplevel-pos (cdr syntax-ppss-last))
(nth 3 syntax-ppss-last)
(if (<= beg (or (syntax-ppss-toplevel-pos (cdr last))
(nth 3 last)
0))
(setq syntax-ppss-last nil)
(setcar syntax-ppss-last nil)))
(setq last nil)
(setcar last nil)))
;; Unregister if there's no cache left. Sadly this doesn't work
;; because `before-change-functions' is temporarily bound to nil here.
;; (unless syntax-ppss-cache
;; (unless cache
;; (remove-hook 'before-change-functions 'syntax-ppss-flush-cache t))
)
(setcar cell last)
(setcdr cell cache)))
))
(defvar syntax-ppss-stats
[(0 . 0.0) (0 . 0.0) (0 . 0.0) (0 . 0.0) (0 . 0.0) (1 . 2500.0)])
@ -423,6 +444,17 @@ point (where the PPSS is equivalent to nil).")
(defvar-local syntax-ppss-table nil
"Syntax-table to use during `syntax-ppss', if any.")
(defun syntax-ppss--data ()
(if (eq (point-min) 1)
(progn
(unless syntax-ppss-wide
(setq syntax-ppss-wide (cons nil nil)))
syntax-ppss-wide)
(unless (eq syntax-ppss-narrow-start (point-min))
(setq syntax-ppss-narrow-start (point-min))
(setq syntax-ppss-narrow (cons nil nil)))
syntax-ppss-narrow))
(defun syntax-ppss (&optional pos)
"Parse-Partial-Sexp State at POS, defaulting to point.
The returned value is the same as that of `parse-partial-sexp'
@ -439,8 +471,11 @@ running the hook."
(syntax-propertize pos)
;;
(with-syntax-table (or syntax-ppss-table (syntax-table))
(let ((old-ppss (cdr syntax-ppss-last))
(old-pos (car syntax-ppss-last))
(let* ((cell (syntax-ppss--data))
(ppss-last (car cell))
(ppss-cache (cdr cell))
(old-ppss (cdr ppss-last))
(old-pos (car ppss-last))
(ppss nil)
(pt-min (point-min)))
(if (and old-pos (> old-pos pos)) (setq old-pos nil))
@ -475,7 +510,7 @@ running the hook."
;; The OLD-* data can't be used. Consult the cache.
(t
(let ((cache-pred nil)
(cache syntax-ppss-cache)
(cache ppss-cache)
(pt-min (point-min))
;; I differentiate between PT-MIN and PT-BEST because
;; I feel like it might be important to ensure that the
@ -491,7 +526,7 @@ running the hook."
(if cache (setq pt-min (caar cache) ppss (cdar cache)))
;; Setup the before-change function if necessary.
(unless (or syntax-ppss-cache syntax-ppss-last)
(unless (or ppss-cache ppss-last)
(add-hook 'before-change-functions
'syntax-ppss-flush-cache t t))
@ -541,7 +576,7 @@ running the hook."
pt-min (setq pt-min (/ (+ pt-min pos) 2))
nil nil ppss))
(push (cons pt-min ppss)
(if cache-pred (cdr cache-pred) syntax-ppss-cache)))
(if cache-pred (cdr cache-pred) ppss-cache)))
;; Compute the actual return value.
(setq ppss (parse-partial-sexp pt-min pos nil nil ppss))
@ -562,13 +597,15 @@ running the hook."
(if (> (- (caar cache-pred) pos) syntax-ppss-max-span)
(push pair (cdr cache-pred))
(setcar cache-pred pair))
(if (or (null syntax-ppss-cache)
(> (- (caar syntax-ppss-cache) pos)
(if (or (null ppss-cache)
(> (- (caar ppss-cache) pos)
syntax-ppss-max-span))
(push pair syntax-ppss-cache)
(setcar syntax-ppss-cache pair)))))))))
(push pair ppss-cache)
(setcar ppss-cache pair)))))))))
(setq syntax-ppss-last (cons pos ppss))
(setq ppss-last (cons pos ppss))
(setcar cell ppss-last)
(setcdr cell ppss-cache)
ppss)
(args-out-of-range
;; If the buffer is more narrowed than when we built the cache,
@ -582,7 +619,7 @@ running the hook."
(defun syntax-ppss-debug ()
(let ((pt nil)
(min-diffs nil))
(dolist (x (append syntax-ppss-cache (list (cons (point-min) nil))))
(dolist (x (append (cdr (syntax-ppss--data)) (list (cons (point-min) nil))))
(when pt (push (- pt (car x)) min-diffs))
(setq pt (car x)))
min-diffs))

2
lisp/eshell/esh-util.el
View file

@ -142,7 +142,7 @@ function `string-to-number'."
(defmacro eshell-condition-case (tag form &rest handlers)
"If `eshell-handle-errors' is non-nil, this is `condition-case'.
Otherwise, evaluates FORM with no error handling."
(declare (indent 2))
(declare (indent 2) (debug (sexp form &rest form)))
(if eshell-handle-errors
`(condition-case-unless-debug ,tag
,form

19
lisp/files.el
View file

@ -150,8 +150,13 @@ Called with an absolute file name as argument, it returns t to enable backup.")
(defcustom buffer-offer-save nil
"Non-nil in a buffer means always offer to save buffer on exit.
Do so even if the buffer is not visiting a file.
Automatically local in all buffers."
:type 'boolean
Automatically local in all buffers.
Set to the symbol `always' to offer to save buffer whenever
`save-some-buffers' is called."
:type '(choice (const :tag "Never" nil)
(const :tag "On Emacs exit" t)
(const :tag "Whenever save-some-buffers is called" always))
:group 'backup)
(make-variable-buffer-local 'buffer-offer-save)
(put 'buffer-offer-save 'permanent-local t)
@ -5188,15 +5193,11 @@ change the additional actions you can take on files."
(and (buffer-live-p buffer)
(buffer-modified-p buffer)
(not (buffer-base-buffer buffer))
(not (eq (aref (buffer-name buffer) 0) ?\s))
(or
(buffer-file-name buffer)
(and pred
(progn
(set-buffer buffer)
(and buffer-offer-save (> (buffer-size) 0))))
(buffer-local-value
'write-contents-functions buffer))
(with-current-buffer buffer
(or (eq buffer-offer-save 'always)
(and pred buffer-offer-save (> (buffer-size) 0)))))
(or (not (functionp pred))
(with-current-buffer buffer (funcall pred)))
(if arg

20
lisp/frame.el
View file

@ -604,11 +604,12 @@ new frame."
(select-frame (make-frame))))
(defvar before-make-frame-hook nil
"Functions to run before a frame is created.")
"Functions to run before `make-frame' creates a new frame.")
(defvar after-make-frame-functions nil
"Functions to run after a frame is created.
The functions are run with one arg, the newly created frame.")
"Functions to run after `make-frame' created a new frame.
The functions are run with one argument, the newly created
frame.")
(defvar after-setting-font-hook nil
"Functions to run after a frame's font has been changed.")
@ -617,7 +618,7 @@ The functions are run with one arg, the newly created frame.")
(define-obsolete-function-alias 'new-frame 'make-frame "22.1")
(defvar frame-inherited-parameters '()
"Parameters `make-frame' copies from the `selected-frame' to the new frame.")
"Parameters `make-frame' copies from the selected to the new frame.")
(defvar x-display-name)
@ -632,9 +633,6 @@ form (NAME . VALUE), for example:
(width . NUMBER) The frame should be NUMBER characters in width.
(height . NUMBER) The frame should be NUMBER text lines high.
You cannot specify either `width' or `height', you must specify
neither or both.
(minibuffer . t) The frame should have a minibuffer.
(minibuffer . nil) The frame should have no minibuffer.
(minibuffer . only) The frame should contain only a minibuffer.
@ -650,10 +648,10 @@ neither or both.
In addition, any parameter specified in `default-frame-alist',
but not present in PARAMETERS, is applied.
Before creating the frame (via `frame-creation-function-alist'),
this function runs the hook `before-make-frame-hook'. After
creating the frame, it runs the hook `after-make-frame-functions'
with one arg, the newly created frame.
Before creating the frame (via `frame-creation-function'), this
function runs the hook `before-make-frame-hook'. After creating
the frame, it runs the hook `after-make-frame-functions' with one
argument, the newly created frame.
If a display parameter is supplied and a window-system is not,
guess the window-system from the display.

6
lisp/net/tramp-smb.el
View file

@ -535,7 +535,7 @@ pass to the OPERATION."
;; Reset the transfer process properties.
(tramp-set-connection-property v "process-name" nil)
(tramp-set-connection-property v "process-buffer" nil)
(when t1 (delete-directory tmpdir 'recurse))))
(when t1 (delete-directory tmpdir 'recursive))))
;; Handle KEEP-DATE argument.
(when keep-date
@ -1583,6 +1583,10 @@ If VEC has no cifs capabilities, exchange \"/\" by \"\\\\\"."
"Read entries which match DIRECTORY.
Either the shares are listed, or the `dir' command is executed.
Result is a list of (LOCALNAME MODE SIZE MONTH DAY TIME YEAR)."
;; If CIFS capabilities are enabled, symlinks are not listed
;; by `dir'. This is a consequence of
;; <https://www.samba.org/samba/news/symlink_attack.html>. See also
;; <https://bugzilla.samba.org/show_bug.cgi?id=5116>.
(with-parsed-tramp-file-name (file-name-as-directory directory) nil
(setq localname (or localname "/"))
(with-tramp-file-property v localname "file-entries"

1100
lisp/progmodes/flymake-proc.el
View file

File diff suppressed because it is too large Load diff

634
lisp/progmodes/flymake-ui.el
View file

@ -1,634 +0,0 @@
;;; flymake-ui.el --- A universal on-the-fly syntax checker -*- lexical-binding: t; -*-
;; Copyright (C) 2003-2017 Free Software Foundation, Inc.
;; Author: Pavel Kobyakov <pk_at_work@yahoo.com>
;; Maintainer: Leo Liu <sdl.web@gmail.com>
;; Version: 0.3
;; Keywords: c languages tools
;; 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 <https://www.gnu.org/licenses/>.
;;; Commentary:
;;
;; Flymake is a minor Emacs mode performing on-the-fly syntax checks.xo
;;
;; This file contains the UI for displaying and interacting with the
;; results of such checks, as well as entry points for backends to
;; hook on to. Backends are sources of diagnostic info.
;;
;;; Code:
(eval-when-compile (require 'cl-lib))
(defgroup flymake nil
"Universal on-the-fly syntax checker."
:version "23.1"
:link '(custom-manual "(flymake) Top")
:group 'tools)
(defcustom flymake-error-bitmap '(exclamation-mark error)
"Bitmap (a symbol) used in the fringe for indicating errors.
The value may also be a list of two elements where the second
element specifies the face for the bitmap. For possible bitmap
symbols, see `fringe-bitmaps'. See also `flymake-warning-bitmap'.
The option `flymake-fringe-indicator-position' controls how and where
this is used."
:group 'flymake
:version "24.3"
:type '(choice (symbol :tag "Bitmap")
(list :tag "Bitmap and face"
(symbol :tag "Bitmap")
(face :tag "Face"))))
(defcustom flymake-warning-bitmap 'question-mark
"Bitmap (a symbol) used in the fringe for indicating warnings.
The value may also be a list of two elements where the second
element specifies the face for the bitmap. For possible bitmap
symbols, see `fringe-bitmaps'. See also `flymake-error-bitmap'.
The option `flymake-fringe-indicator-position' controls how and where
this is used."
:group 'flymake
:version "24.3"
:type '(choice (symbol :tag "Bitmap")
(list :tag "Bitmap and face"
(symbol :tag "Bitmap")
(face :tag "Face"))))
(defcustom flymake-fringe-indicator-position 'left-fringe
"The position to put flymake fringe indicator.
The value can be nil (do not use indicators), `left-fringe' or `right-fringe'.
See `flymake-error-bitmap' and `flymake-warning-bitmap'."
:group 'flymake
:version "24.3"
:type '(choice (const left-fringe)
(const right-fringe)
(const :tag "No fringe indicators" nil)))
(defcustom flymake-start-syntax-check-on-newline t
"Start syntax check if newline char was added/removed from the buffer."
:group 'flymake
:type 'boolean)
(defcustom flymake-no-changes-timeout 0.5
"Time to wait after last change before starting compilation."
:group 'flymake
:type 'number)
(defcustom flymake-gui-warnings-enabled t
"Enables/disables GUI warnings."
:group 'flymake
:type 'boolean)
(make-obsolete-variable 'flymake-gui-warnings-enabled
"it no longer has any effect." "26.1")
(defcustom flymake-start-syntax-check-on-find-file t
"Start syntax check on find file."
:group 'flymake
:type 'boolean)
(defcustom flymake-log-level -1
"Logging level, only messages with level lower or equal will be logged.
-1 = NONE, 0 = ERROR, 1 = WARNING, 2 = INFO, 3 = DEBUG"
:group 'flymake
:type 'integer)
(defcustom flymake-backends '()
"Ordered list of backends providing syntax check information for a buffer.
Value is an alist of conses (PREDICATE . CHECKER). Both PREDICATE
and CHECKER are functions called with a single argument, the
buffer in which `flymake-mode' was enabled. PREDICATE is expected
to (quickly) return t or nil if the buffer can be syntax checked
by CHECKER, which in can performs more morose operations,
possibly asynchronously."
:group 'flymake
:type 'alist)
(defvar-local flymake-timer nil
"Timer for starting syntax check.")
(defvar-local flymake-last-change-time nil
"Time of last buffer change.")
(defvar-local flymake-check-start-time nil
"Time at which syntax check was started.")
(defvar-local flymake-check-was-interrupted nil
"Non-nil if syntax check was killed by `flymake-compile'.")
(defvar-local flymake-err-info nil
"Sorted list of line numbers and lists of err info in the form (file, err-text).")
(defvar-local flymake-new-err-info nil
"Same as `flymake-err-info', effective when a syntax check is in progress.")
(defun flymake-log (level text &rest args)
"Log a message at level LEVEL.
If LEVEL is higher than `flymake-log-level', the message is
ignored. Otherwise, it is printed using `message'.
TEXT is a format control string, and the remaining arguments ARGS
are the string substitutions (see the function `format')."
(if (<= level flymake-log-level)
(let* ((msg (apply #'format-message text args)))
(message "%s" msg))))
(defun flymake-ins-after (list pos val)
"Insert VAL into LIST after position POS.
POS counts from zero."
(let ((tmp (copy-sequence list)))
(setcdr (nthcdr pos tmp) (cons val (nthcdr (1+ pos) tmp)))
tmp))
(defun flymake-set-at (list pos val)
"Set VAL at position POS in LIST.
POS counts from zero."
(let ((tmp (copy-sequence list)))
(setcar (nthcdr pos tmp) val)
tmp))
(defun flymake-er-make-er (line-no line-err-info-list)
(list line-no line-err-info-list))
(defun flymake-er-get-line (err-info)
(nth 0 err-info))
(defun flymake-er-get-line-err-info-list (err-info)
(nth 1 err-info))
(cl-defstruct (flymake-ler
(:constructor nil)
(:constructor flymake-ler-make-ler (file line type text &optional full-file)))
file line type text full-file)
(defun flymake-ler-set-file (line-err-info file)
(flymake-ler-make-ler file
(flymake-ler-line line-err-info)
(flymake-ler-type line-err-info)
(flymake-ler-text line-err-info)
(flymake-ler-full-file line-err-info)))
(defun flymake-ler-set-full-file (line-err-info full-file)
(flymake-ler-make-ler (flymake-ler-file line-err-info)
(flymake-ler-line line-err-info)
(flymake-ler-type line-err-info)
(flymake-ler-text line-err-info)
full-file))
(defun flymake-ler-set-line (line-err-info line)
(flymake-ler-make-ler (flymake-ler-file line-err-info)
line
(flymake-ler-type line-err-info)
(flymake-ler-text line-err-info)
(flymake-ler-full-file line-err-info)))
(defun flymake-get-line-err-count (line-err-info-list type)
"Return number of errors of specified TYPE.
Value of TYPE is either \"e\" or \"w\"."
(let* ((idx 0)
(count (length line-err-info-list))
(err-count 0))
(while (< idx count)
(when (equal type (flymake-ler-type (nth idx line-err-info-list)))
(setq err-count (1+ err-count)))
(setq idx (1+ idx)))
err-count))
(defun flymake-get-err-count (err-info-list type)
"Return number of errors of specified TYPE for ERR-INFO-LIST."
(let* ((idx 0)
(count (length err-info-list))
(err-count 0))
(while (< idx count)
(setq err-count (+ err-count (flymake-get-line-err-count (nth 1 (nth idx err-info-list)) type)))
(setq idx (1+ idx)))
err-count))
(defun flymake-highlight-err-lines (err-info-list)
"Highlight error lines in BUFFER using info from ERR-INFO-LIST."
(save-excursion
(dolist (err err-info-list)
(flymake-highlight-line (car err) (nth 1 err)))))
(defun flymake-overlay-p (ov)
"Determine whether overlay OV was created by flymake."
(and (overlayp ov) (overlay-get ov 'flymake-overlay)))
(defun flymake-make-overlay (beg end tooltip-text face bitmap)
"Allocate a flymake overlay in range BEG and END."
(when (not (flymake-region-has-flymake-overlays beg end))
(let ((ov (make-overlay beg end nil t))
(fringe (and flymake-fringe-indicator-position
(propertize "!" 'display
(cons flymake-fringe-indicator-position
(if (listp bitmap)
bitmap
(list bitmap)))))))
(overlay-put ov 'face face)
(overlay-put ov 'help-echo tooltip-text)
(overlay-put ov 'flymake-overlay t)
(overlay-put ov 'priority 100)
(overlay-put ov 'evaporate t)
(overlay-put ov 'before-string fringe)
;;+(flymake-log 3 "created overlay %s" ov)
ov)
(flymake-log 3 "created an overlay at (%d-%d)" beg end)))
(defun flymake-delete-own-overlays ()
"Delete all flymake overlays in BUFFER."
(dolist (ol (overlays-in (point-min) (point-max)))
(when (flymake-overlay-p ol)
(delete-overlay ol)
;;+(flymake-log 3 "deleted overlay %s" ol)
)))
(defun flymake-region-has-flymake-overlays (beg end)
"Check if region specified by BEG and END has overlay.
Return t if it has at least one flymake overlay, nil if no overlay."
(let ((ov (overlays-in beg end))
(has-flymake-overlays nil))
(while (consp ov)
(when (flymake-overlay-p (car ov))
(setq has-flymake-overlays t))
(setq ov (cdr ov)))
has-flymake-overlays))
(defface flymake-errline
'((((supports :underline (:style wave)))
:underline (:style wave :color "Red1"))
(t
:inherit error))
"Face used for marking error lines."
:version "24.4"
:group 'flymake)
(defface flymake-warnline
'((((supports :underline (:style wave)))
:underline (:style wave :color "DarkOrange"))
(t
:inherit warning))
"Face used for marking warning lines."
:version "24.4"
:group 'flymake)
(defun flymake-highlight-line (line-no line-err-info-list)
"Highlight line LINE-NO in current buffer.
Perhaps use text from LINE-ERR-INFO-LIST to enhance highlighting."
(goto-char (point-min))
(forward-line (1- line-no))
(pcase-let* ((beg (progn (back-to-indentation) (point)))
(end (progn
(end-of-line)
(skip-chars-backward " \t\f\t\n" beg)
(if (eq (point) beg)
(line-beginning-position 2)
(point))))
(tooltip-text (mapconcat #'flymake-ler-text line-err-info-list "\n"))
(`(,face ,bitmap)
(if (> (flymake-get-line-err-count line-err-info-list "e") 0)
(list 'flymake-errline flymake-error-bitmap)
(list 'flymake-warnline flymake-warning-bitmap))))
(flymake-make-overlay beg end tooltip-text face bitmap)))
(defun flymake-find-err-info (err-info-list line-no)
"Find (line-err-info-list pos) for specified LINE-NO."
(if err-info-list
(let* ((line-err-info-list nil)
(pos 0)
(count (length err-info-list)))
(while (and (< pos count) (< (car (nth pos err-info-list)) line-no))
(setq pos (1+ pos)))
(when (and (< pos count) (equal (car (nth pos err-info-list)) line-no))
(setq line-err-info-list (flymake-er-get-line-err-info-list (nth pos err-info-list))))
(list line-err-info-list pos))
'(nil 0)))
(defun flymake-line-err-info-is-less-or-equal (line-one line-two)
(or (string< (flymake-ler-type line-one) (flymake-ler-type line-two))
(and (string= (flymake-ler-type line-one) (flymake-ler-type line-two))
(not (flymake-ler-file line-one)) (flymake-ler-file line-two))
(and (string= (flymake-ler-type line-one) (flymake-ler-type line-two))
(or (and (flymake-ler-file line-one) (flymake-ler-file line-two))
(and (not (flymake-ler-file line-one)) (not (flymake-ler-file line-two)))))))
(defun flymake-add-line-err-info (line-err-info-list line-err-info)
"Update LINE-ERR-INFO-LIST with the error LINE-ERR-INFO.
For the format of LINE-ERR-INFO, see `flymake-ler-make-ler'.
The new element is inserted in the proper position, according to
the predicate `flymake-line-err-info-is-less-or-equal'.
The updated value of LINE-ERR-INFO-LIST is returned."
(if (not line-err-info-list)
(list line-err-info)
(let* ((count (length line-err-info-list))
(idx 0))
(while (and (< idx count) (flymake-line-err-info-is-less-or-equal (nth idx line-err-info-list) line-err-info))
(setq idx (1+ idx)))
(cond ((equal 0 idx) (setq line-err-info-list (cons line-err-info line-err-info-list)))
(t (setq line-err-info-list (flymake-ins-after line-err-info-list (1- idx) line-err-info))))
line-err-info-list)))
(defun flymake-add-err-info (err-info-list line-err-info)
"Update ERR-INFO-LIST with the error LINE-ERR-INFO, preserving sort order.
Returns the updated value of ERR-INFO-LIST.
For the format of ERR-INFO-LIST, see `flymake-err-info'.
For the format of LINE-ERR-INFO, see `flymake-ler-make-ler'."
(let* ((line-no (if (flymake-ler-file line-err-info) 1 (flymake-ler-line line-err-info)))
(info-and-pos (flymake-find-err-info err-info-list line-no))
(exists (car info-and-pos))
(pos (nth 1 info-and-pos))
(line-err-info-list nil)
(err-info nil))
(if exists
(setq line-err-info-list (flymake-er-get-line-err-info-list (car (nthcdr pos err-info-list)))))
(setq line-err-info-list (flymake-add-line-err-info line-err-info-list line-err-info))
(setq err-info (flymake-er-make-er line-no line-err-info-list))
(cond (exists (setq err-info-list (flymake-set-at err-info-list pos err-info)))
((equal 0 pos) (setq err-info-list (cons err-info err-info-list)))
(t (setq err-info-list (flymake-ins-after err-info-list (1- pos) err-info))))
err-info-list))
(defvar-local flymake-is-running nil
"If t, flymake syntax check process is running for the current buffer.")
(defun flymake-on-timer-event (buffer)
"Start a syntax check for buffer BUFFER if necessary."
(when (buffer-live-p buffer)
(with-current-buffer buffer
(when (and (not flymake-is-running)
flymake-last-change-time
(> (- (float-time) flymake-last-change-time)
flymake-no-changes-timeout))
(setq flymake-last-change-time nil)
(flymake-log 3 "starting syntax check as more than 1 second passed since last change")
(flymake--start-syntax-check)))))
(define-obsolete-function-alias 'flymake-display-err-menu-for-current-line
'flymake-popup-current-error-menu "24.4")
(defun flymake-popup-current-error-menu (&optional event)
"Pop up a menu with errors/warnings for current line."
(interactive (list last-nonmenu-event))
(let* ((line-no (line-number-at-pos))
(errors (or (car (flymake-find-err-info flymake-err-info line-no))
(user-error "No errors for current line")))
(menu (mapcar (lambda (x)
(if (flymake-ler-file x)
(cons (format "%s - %s(%d)"
(flymake-ler-text x)
(flymake-ler-file x)
(flymake-ler-line x))
x)
(list (flymake-ler-text x))))
errors))
(event (if (mouse-event-p event)
event
(list 'mouse-1 (posn-at-point))))
(title (format "Line %d: %d error(s), %d warning(s)"
line-no
(flymake-get-line-err-count errors "e")
(flymake-get-line-err-count errors "w")))
(choice (x-popup-menu event (list title (cons "" menu)))))
(flymake-log 3 "choice=%s" choice)
(when choice
(flymake-goto-file-and-line (flymake-ler-full-file choice)
(flymake-ler-line choice)))))
(defun flymake-goto-file-and-line (file line)
"Try to get buffer for FILE and goto line LINE in it."
(if (not (file-exists-p file))
(flymake-log 1 "File %s does not exist" file)
(find-file file)
(goto-char (point-min))
(forward-line (1- line))))
;; flymake minor mode declarations
(defvar-local flymake-mode-line nil)
(defvar-local flymake-mode-line-e-w nil)
(defvar-local flymake-mode-line-status nil)
(defun flymake-report-status (e-w &optional status)
"Show status in mode line."
(when e-w
(setq flymake-mode-line-e-w e-w))
(when status
(setq flymake-mode-line-status status))
(let* ((mode-line " Flymake"))
(when (> (length flymake-mode-line-e-w) 0)
(setq mode-line (concat mode-line ":" flymake-mode-line-e-w)))
(setq mode-line (concat mode-line flymake-mode-line-status))
(setq flymake-mode-line mode-line)
(force-mode-line-update)))
;; Nothing in flymake uses this at all any more, so this is just for
;; third-party compatibility.
(define-obsolete-function-alias 'flymake-display-warning 'message-box "26.1")
(defun flymake-report-fatal-status (status warning)
"Display a warning and switch flymake mode off."
;; This first message was always shown by default, and flymake-log
;; does nothing by default, hence the use of message.
;; Another option is display-warning.
(if (< flymake-log-level 0)
(message "Flymake: %s. Flymake will be switched OFF" warning))
(flymake-mode 0)
(flymake-log 0 "switched OFF Flymake mode for buffer %s due to fatal status %s, warning %s"
(buffer-name) status warning))
(defvar-local flymake--backend nil
"The currently active backend selected by `flymake-mode'")
(defun flymake--can-syntax-check-buffer (buffer)
(let ((all flymake-backends)
(candidate))
(catch 'done
(while (setq candidate (pop all))
(when (with-current-buffer buffer (funcall (car candidate)))
(throw 'done (cdr candidate)))))))
(defun flymake--start-syntax-check ()
(funcall flymake--backend))
;;;###autoload
(define-minor-mode flymake-mode nil
:group 'flymake :lighter flymake-mode-line
(cond
;; Turning the mode ON.
(flymake-mode
(let* ((backend (flymake--can-syntax-check-buffer (current-buffer))))
(cond
((not backend)
(flymake-log 2 "flymake cannot check syntax in buffer %s" (buffer-name)))
(t
(setq flymake--backend backend)
(add-hook 'after-change-functions 'flymake-after-change-function nil t)
(add-hook 'after-save-hook 'flymake-after-save-hook nil t)
(add-hook 'kill-buffer-hook 'flymake-kill-buffer-hook nil t)
;;+(add-hook 'find-file-hook 'flymake-find-file-hook)
(flymake-report-status "" "")
(setq flymake-timer
(run-at-time nil 1 'flymake-on-timer-event (current-buffer)))
(when (and flymake-start-syntax-check-on-find-file
;; Since we write temp files in current dir, there's no point
;; trying if the directory is read-only (bug#8954).
(file-writable-p (file-name-directory buffer-file-name)))
(with-demoted-errors
(flymake--start-syntax-check)))))
)
)
;; Turning the mode OFF.
(t
(setq flymake--backend nil)
(remove-hook 'after-change-functions 'flymake-after-change-function t)
(remove-hook 'after-save-hook 'flymake-after-save-hook t)
(remove-hook 'kill-buffer-hook 'flymake-kill-buffer-hook t)
;;+(remove-hook 'find-file-hook (function flymake-find-file-hook) t)
(flymake-delete-own-overlays)
(when flymake-timer
(cancel-timer flymake-timer)
(setq flymake-timer nil))
(setq flymake-is-running nil))))
;; disabling flymake-mode is safe, enabling - not necessarily so
(put 'flymake-mode 'safe-local-variable 'null)
;;;###autoload
(defun flymake-mode-on ()
"Turn flymake mode on."
(flymake-mode 1)
(flymake-log 1 "flymake mode turned ON for buffer %s" (buffer-name)))
;;;###autoload
(defun flymake-mode-off ()
"Turn flymake mode off."
(flymake-mode 0)
(flymake-log 1 "flymake mode turned OFF for buffer %s" (buffer-name)))
(defun flymake-after-change-function (start stop _len)
"Start syntax check for current buffer if it isn't already running."
;;+(flymake-log 0 "setting change time to %s" (float-time))
(let((new-text (buffer-substring start stop)))
(when (and flymake-start-syntax-check-on-newline (equal new-text "\n"))
(flymake-log 3 "starting syntax check as new-line has been seen")
(flymake--start-syntax-check))
(setq flymake-last-change-time (float-time))))
(defun flymake-after-save-hook ()
(if (local-variable-p 'flymake-mode (current-buffer)) ; (???) other way to determine whether flymake is active in buffer being saved?
(progn
(flymake-log 3 "starting syntax check as buffer was saved")
(flymake--start-syntax-check)))) ; no more mode 3. cannot start check if mode 3 (to temp copies) is active - (???)
(defun flymake-kill-buffer-hook ()
(when flymake-timer
(cancel-timer flymake-timer)
(setq flymake-timer nil)))
;;;###autoload
(defun flymake-find-file-hook ()
;;+(when flymake-start-syntax-check-on-find-file
;;+ (flymake-log 3 "starting syntax check on file open")
;;+ (flymake--start-syntax-check)
;;+)
(when (and (not (local-variable-p 'flymake-mode (current-buffer)))
(flymake--can-syntax-check-buffer (current-buffer)))
(flymake-mode)
(flymake-log 3 "automatically turned ON flymake mode")))
(defun flymake-get-first-err-line-no (err-info-list)
"Return first line with error."
(when err-info-list
(flymake-er-get-line (car err-info-list))))
(defun flymake-get-last-err-line-no (err-info-list)
"Return last line with error."
(when err-info-list
(flymake-er-get-line (nth (1- (length err-info-list)) err-info-list))))
(defun flymake-get-next-err-line-no (err-info-list line-no)
"Return next line with error."
(when err-info-list
(let* ((count (length err-info-list))
(idx 0))
(while (and (< idx count) (>= line-no (flymake-er-get-line (nth idx err-info-list))))
(setq idx (1+ idx)))
(if (< idx count)
(flymake-er-get-line (nth idx err-info-list))))))
(defun flymake-get-prev-err-line-no (err-info-list line-no)
"Return previous line with error."
(when err-info-list
(let* ((count (length err-info-list)))
(while (and (> count 0) (<= line-no (flymake-er-get-line (nth (1- count) err-info-list))))
(setq count (1- count)))
(if (> count 0)
(flymake-er-get-line (nth (1- count) err-info-list))))))
(defun flymake-skip-whitespace ()
"Move forward until non-whitespace is reached."
(while (looking-at "[ \t]")
(forward-char)))
(defun flymake-goto-line (line-no)
"Go to line LINE-NO, then skip whitespace."
(goto-char (point-min))
(forward-line (1- line-no))
(flymake-skip-whitespace))
(defun flymake-goto-next-error ()
"Go to next error in err ring."
(interactive)
(let ((line-no (flymake-get-next-err-line-no flymake-err-info (line-number-at-pos))))
(when (not line-no)
(setq line-no (flymake-get-first-err-line-no flymake-err-info))
(flymake-log 1 "passed end of file"))
(if line-no
(flymake-goto-line line-no)
(flymake-log 1 "no errors in current buffer"))))
(defun flymake-goto-prev-error ()
"Go to previous error in err ring."
(interactive)
(let ((line-no (flymake-get-prev-err-line-no flymake-err-info (line-number-at-pos))))
(when (not line-no)
(setq line-no (flymake-get-last-err-line-no flymake-err-info))
(flymake-log 1 "passed beginning of file"))
(if line-no
(flymake-goto-line line-no)
(flymake-log 1 "no errors in current buffer"))))
(defun flymake-patch-err-text (string)
(if (string-match "^[\n\t :0-9]*\\(.*\\)$" string)
(match-string 1 string)
string))
(provide 'flymake-ui)
;;; flymake-ui.el ends here

1629
lisp/progmodes/flymake.el
View file

File diff suppressed because it is too large Load diff

6
lisp/progmodes/python.el
View file

@ -4271,8 +4271,10 @@ See `python-check-command' for the default."
import inspect
try:
str_type = basestring
argspec_function = inspect.getargspec
except NameError:
str_type = str
argspec_function = inspect.getfullargspec
if isinstance(obj, str_type):
obj = eval(obj, globals())
doc = inspect.getdoc(obj)
@ -4285,9 +4287,7 @@ See `python-check-command' for the default."
target = obj
objtype = 'def'
if target:
args = inspect.formatargspec(
*inspect.getargspec(target)
)
args = inspect.formatargspec(*argspec_function(target))
name = obj.__name__
doc = '{objtype} {name}{args}'.format(
objtype=objtype, name=name, args=args

34
lisp/progmodes/sh-script.el
View file

@ -593,11 +593,7 @@ sign. See `sh-feature'."
(sexp :format "Evaluate: %v"))))
:group 'sh-script)
(defcustom sh-indentation 4
"The width for further indentation in Shell-Script mode."
:type 'integer
:group 'sh-script)
(define-obsolete-variable-alias 'sh-indentation 'sh-basic-offset "26.1")
(put 'sh-indentation 'safe-local-variable 'integerp)
(defcustom sh-remember-variable-min 3
@ -1617,7 +1613,7 @@ with your script for an edit-interpret-debug cycle."
(setq-local skeleton-pair-alist '((?` _ ?`)))
(setq-local skeleton-pair-filter-function 'sh-quoted-p)
(setq-local skeleton-further-elements
'((< '(- (min sh-indentation (current-column))))))
'((< '(- (min sh-basic-offset (current-column))))))
(setq-local skeleton-filter-function 'sh-feature)
(setq-local skeleton-newline-indent-rigidly t)
(setq-local defun-prompt-regexp
@ -2012,7 +2008,7 @@ May return nil if the line should not be treated as continued."
(forward-line -1)
(if (sh-smie--looking-back-at-continuation-p)
(current-indentation)
(+ (current-indentation) sh-indentation))))
(+ (current-indentation) sh-basic-offset))))
(t
;; Just make sure a line-continuation is indented deeper.
(save-excursion
@ -2033,13 +2029,13 @@ May return nil if the line should not be treated as continued."
;; check the line before that one.
(> ci indent))
(t ;Previous line is the beginning of the continued line.
(setq indent (min (+ ci sh-indentation) max))
(setq indent (min (+ ci sh-basic-offset) max))
nil)))))
indent))))))
(defun sh-smie-sh-rules (kind token)
(pcase (cons kind token)
(`(:elem . basic) sh-indentation)
(`(:elem . basic) sh-basic-offset)
(`(:after . "case-)") (- (sh-var-value 'sh-indent-for-case-alt)
(sh-var-value 'sh-indent-for-case-label)))
(`(:before . ,(or `"(" `"{" `"[" "while" "if" "for" "case"))
@ -2248,8 +2244,8 @@ Point should be before the newline."
(defun sh-smie-rc-rules (kind token)
(pcase (cons kind token)
(`(:elem . basic) sh-indentation)
;; (`(:after . "case") (or sh-indentation smie-indent-basic))
(`(:elem . basic) sh-basic-offset)
;; (`(:after . "case") (or sh-basic-offset smie-indent-basic))
(`(:after . ";")
(if (smie-rule-parent-p "case")
(smie-rule-parent (sh-var-value 'sh-indent-after-case))))
@ -2490,7 +2486,7 @@ the value thus obtained, and the result is used instead."
(defun sh-basic-indent-line ()
"Indent a line for Sh mode (shell script mode).
Indent as far as preceding non-empty line, then by steps of `sh-indentation'.
Indent as far as preceding non-empty line, then by steps of `sh-basic-offset'.
Lines containing only comments are considered empty."
(interactive)
(let ((previous (save-excursion
@ -2514,9 +2510,9 @@ Lines containing only comments are considered empty."
(delete-region (point)
(progn (beginning-of-line) (point)))
(if (eolp)
(max previous (* (1+ (/ current sh-indentation))
sh-indentation))
(* (1+ (/ current sh-indentation)) sh-indentation))))))
(max previous (* (1+ (/ current sh-basic-offset))
sh-basic-offset))
(* (1+ (/ current sh-basic-offset)) sh-basic-offset))))))
(if (< (current-column) (current-indentation))
(skip-chars-forward " \t"))))
@ -3594,6 +3590,10 @@ so that `occur-next' and `occur-prev' will work."
(defun sh-learn-buffer-indent (&optional arg)
"Learn how to indent the buffer the way it currently is.
If `sh-use-smie' is non-nil, call `smie-config-guess'.
Otherwise, run the sh-script specific indent learning command, as
decribed below.
Output in buffer \"*indent*\" shows any lines which have conflicting
values of a variable, and the final value of all variables learned.
When called interactively, pop to this buffer automatically if
@ -3610,8 +3610,7 @@ to the value of variable `sh-learn-basic-offset'.
Abnormal hook `sh-learned-buffer-hook' if non-nil is called when the
function completes. The function is abnormal because it is called
with an alist of variables learned. This feature may be changed or
removed in the future.
with an alist of variables learned.
This command can often take a long time to run."
(interactive "P")
@ -3809,7 +3808,6 @@ This command can often take a long time to run."
" has" "s have")
(if (zerop num-diffs)
"." ":"))))))
;; Are abnormal hooks considered bad form?
(run-hook-with-args 'sh-learned-buffer-hook learned-var-list)
(and (called-interactively-p 'any)
(or sh-popup-occur-buffer (> num-diffs 0))

2
lisp/progmodes/xref.el
View file

@ -928,12 +928,14 @@ IGNORES is a list of glob patterns."
files
(expand-file-name dir)
ignores))
(def default-directory)
(buf (get-buffer-create " *xref-grep*"))
(`(,grep-re ,file-group ,line-group . ,_) (car grep-regexp-alist))
(status nil)
(hits nil))
(with-current-buffer buf
(erase-buffer)
(setq default-directory def)
(setq status
(call-process-shell-command command nil t))
(goto-char (point-min))

20
lisp/simple.el
View file

@ -39,11 +39,11 @@
(defcustom shell-command-dont-erase-buffer nil
"If non-nil, output buffer is not erased between shell commands.
Also, a non-nil value set the point in the output buffer
once the command complete.
The value `beg-last-out' set point at the beginning of the output,
`end-last-out' set point at the end of the buffer, `save-point'
restore the buffer position before the command."
Also, a non-nil value sets the point in the output buffer
once the command completes.
The value `beg-last-out' sets point at the beginning of the output,
`end-last-out' sets point at the end of the buffer, `save-point'
restores the buffer position before the command."
:type '(choice
(const :tag "Erase buffer" nil)
(const :tag "Set point to beginning of last output" beg-last-out)
@ -53,9 +53,9 @@ restore the buffer position before the command."
:version "26.1")
(defvar shell-command-saved-pos nil
"Point position in the output buffer after command complete.
It is an alist (BUFFER . POS), where BUFFER is the output
buffer, and POS is the point position in BUFFER once the command finish.
"Point position in the output buffer after command completes.
It is an alist of (BUFFER . POS), where BUFFER is the output
buffer, and POS is the point position in BUFFER once the command finishes.
This variable is used when `shell-command-dont-erase-buffer' is non-nil.")
(defcustom idle-update-delay 0.5
@ -1003,7 +1003,7 @@ Called with one argument METHOD.
If METHOD is `delete-only', then delete the region; the return value
is undefined. If METHOD is nil, then return the content as a string.
If METHOD is `bounds', then return the boundaries of the region
as a list of the form (START . END).
as a list of pairs of (START . END) positions.
If METHOD is anything else, delete the region and return its content
as a string, after filtering it with `filter-buffer-substring', which
is called with METHOD as its 3rd argument.")
@ -5473,7 +5473,7 @@ also checks the value of `use-empty-active-region'."
(progn (cl-assert (mark)) t)))
(defun region-bounds ()
"Return the boundaries of the region as a list of (START . END) positions."
"Return the boundaries of the region as a list of pairs of (START . END) positions."
(funcall region-extract-function 'bounds))
(defun region-noncontiguous-p ()

4
lisp/xdg.el
View file

@ -84,7 +84,7 @@
(defun xdg-thumb-uri (filename)
"Return the canonical URI for FILENAME.
If FILENAME has absolute path /foo/bar.jpg, its canonical URI is
If FILENAME has absolute file name /foo/bar.jpg, its canonical URI is
file:///foo/bar.jpg"
(concat "file://" (expand-file-name filename)))
@ -197,8 +197,6 @@ Optional argument GROUP defaults to the string \"Desktop Entry\"."
(unless (looking-at xdg-desktop-group-regexp)
(error "Expected group name! Instead saw: %s"
(buffer-substring (point) (point-at-eol))))
(unless (equal (match-string 1) "Desktop Entry")
(error "Wrong first group: %s" (match-string 1)))
(when group
(while (and (re-search-forward xdg-desktop-group-regexp nil t)
(not (equal (match-string 1) group)))))

7
src/callint.c
View file

@ -272,7 +272,7 @@ invoke it. If KEYS is omitted or nil, the return value of
{
/* `args' will contain the array of arguments to pass to the function.
`visargs' will contain the same list but in a nicer form, so that if we
pass it to `Fformat_message' it will be understandable to a human. */
pass it to styled_format it will be understandable to a human. */
Lisp_Object *args, *visargs;
Lisp_Object specs;
Lisp_Object filter_specs;
@ -502,10 +502,7 @@ invoke it. If KEYS is omitted or nil, the return value of
for (i = 2; *tem; i++)
{
visargs[1] = make_string (tem + 1, strcspn (tem + 1, "\n"));
if (strchr (SSDATA (visargs[1]), '%'))
callint_message = Fformat_message (i - 1, visargs + 1);
else
callint_message = visargs[1];
callint_message = styled_format (i - 1, visargs + 1, true, false);
switch (*tem)
{

3
src/dbusbind.c
View file

@ -237,7 +237,8 @@ static char *
XD_OBJECT_TO_STRING (Lisp_Object object)
{
AUTO_STRING (format, "%s");
return SSDATA (CALLN (Fformat, format, object));
Lisp_Object args[] = { format, object };
return SSDATA (styled_format (ARRAYELTS (args), args, false, false));
}
#define XD_DBUS_VALIDATE_BUS_ADDRESS(bus) \

42
src/editfns.c
View file

@ -74,7 +74,6 @@ static Lisp_Object format_time_string (char const *, ptrdiff_t, struct timespec,
static long int tm_gmtoff (struct tm *);
static int tm_diff (struct tm *, struct tm *);
static void update_buffer_properties (ptrdiff_t, ptrdiff_t);
static Lisp_Object styled_format (ptrdiff_t, Lisp_Object *, bool);
#ifndef HAVE_TM_GMTOFF
# define HAVE_TM_GMTOFF false
@ -3959,7 +3958,7 @@ usage: (message FORMAT-STRING &rest ARGS) */)
}
else
{
Lisp_Object val = Fformat_message (nargs, args);
Lisp_Object val = styled_format (nargs, args, true, false);
message3 (val);
return val;
}
@ -3985,7 +3984,7 @@ usage: (message-box FORMAT-STRING &rest ARGS) */)
}
else
{
Lisp_Object val = Fformat_message (nargs, args);
Lisp_Object val = styled_format (nargs, args, true, false);
Lisp_Object pane, menu;
pane = list1 (Fcons (build_string ("OK"), Qt));
@ -4141,7 +4140,7 @@ produced text.
usage: (format STRING &rest OBJECTS) */)
(ptrdiff_t nargs, Lisp_Object *args)
{
return styled_format (nargs, args, false);
return styled_format (nargs, args, false, true);
}
DEFUN ("format-message", Fformat_message, Sformat_message, 1, MANY, 0,
@ -4157,13 +4156,16 @@ and right quote replacement characters are specified by
usage: (format-message STRING &rest OBJECTS) */)
(ptrdiff_t nargs, Lisp_Object *args)
{
return styled_format (nargs, args, true);
return styled_format (nargs, args, true, true);
}
/* Implement ‘format-message’ if MESSAGE is true, ‘format’ otherwise. */
/* Implement ‘format-message’ if MESSAGE is true, ‘format’ otherwise.
If NEW_RESULT, the result is a new string; otherwise, the result
may be one of the arguments. */
static Lisp_Object
styled_format (ptrdiff_t nargs, Lisp_Object *args, bool message)
Lisp_Object
styled_format (ptrdiff_t nargs, Lisp_Object *args, bool message,
bool new_result)
{
ptrdiff_t n; /* The number of the next arg to substitute. */
char initial_buffer[4000];
@ -4193,6 +4195,9 @@ styled_format (ptrdiff_t nargs, Lisp_Object *args, bool message)
/* The start and end bytepos in the output string. */
ptrdiff_t start, end;
/* Whether the argument is a newly created string. */
bool_bf new_string : 1;
/* Whether the argument is a string with intervals. */
bool_bf intervals : 1;
} *info;
@ -4342,7 +4347,10 @@ styled_format (ptrdiff_t nargs, Lisp_Object *args, bool message)
memset (&discarded[format0 - format_start], 1,
format - format0 - (conversion == '%'));
if (conversion == '%')
{
new_result = true;
goto copy_char;
}
++n;
if (! (n < nargs))
@ -4352,6 +4360,7 @@ styled_format (ptrdiff_t nargs, Lisp_Object *args, bool message)
if (nspec < ispec)
{
spec->argument = args[n];
spec->new_string = false;
spec->intervals = false;
nspec = ispec;
}
@ -4369,6 +4378,7 @@ styled_format (ptrdiff_t nargs, Lisp_Object *args, bool message)
{
Lisp_Object noescape = conversion == 'S' ? Qnil : Qt;
spec->argument = arg = Fprin1_to_string (arg, noescape);
spec->new_string = true;
if (STRING_MULTIBYTE (arg) && ! multibyte)
{
multibyte = true;
@ -4387,6 +4397,7 @@ styled_format (ptrdiff_t nargs, Lisp_Object *args, bool message)
goto retry;
}
spec->argument = arg = Fchar_to_string (arg);
spec->new_string = true;
}
if (!EQ (arg, args[n]))
@ -4409,6 +4420,11 @@ styled_format (ptrdiff_t nargs, Lisp_Object *args, bool message)
if (conversion == 's')
{
if (format == end && format - format_start == 2
&& (!new_result || spec->new_string)
&& ! string_intervals (args[0]))
return arg;
/* handle case (precision[n] >= 0) */
ptrdiff_t prec = -1;
@ -4487,6 +4503,7 @@ styled_format (ptrdiff_t nargs, Lisp_Object *args, bool message)
if (string_intervals (arg))
spec->intervals = arg_intervals = true;
new_result = true;
continue;
}
}
@ -4754,6 +4771,7 @@ styled_format (ptrdiff_t nargs, Lisp_Object *args, bool message)
}
spec->end = nchars;
new_result = true;
continue;
}
}
@ -4772,9 +4790,13 @@ styled_format (ptrdiff_t nargs, Lisp_Object *args, bool message)
}
convsrc = format_char == '`' ? uLSQM : uRSQM;
convbytes = 3;
new_result = true;
}
else if (format_char == '`' && quoting_style == STRAIGHT_QUOTING_STYLE)
{
convsrc = "'";
new_result = true;
}
else
{
/* Copy a single character from format to buf. */
@ -4798,6 +4820,7 @@ styled_format (ptrdiff_t nargs, Lisp_Object *args, bool message)
int c = BYTE8_TO_CHAR (format_char);
convbytes = CHAR_STRING (c, str);
convsrc = (char *) str;
new_result = true;
}
}
@ -4844,6 +4867,9 @@ styled_format (ptrdiff_t nargs, Lisp_Object *args, bool message)
if (bufsize < p - buf)
emacs_abort ();
if (! new_result)
return args[0];
if (maybe_combine_byte)
nchars = multibyte_chars_in_text ((unsigned char *) buf, p - buf);
Lisp_Object val = make_specified_string (buf, nchars, p - buf, multibyte);

5
src/gtkutil.c
View file

@ -1217,7 +1217,10 @@ xg_create_frame_widgets (struct frame *f)
with regular X drawing primitives, so from a GTK/GDK point of
view, the widget is totally blank. When an expose comes, this
will make the widget blank, and then Emacs redraws it. This flickers
a lot, so we turn off double buffering. */
a lot, so we turn off double buffering.
FIXME: gtk_widget_set_double_buffered is deprecated and might stop
working in the future. We need to migrate away from combining
X and GTK+ drawing to a pure GTK+ build. */
gtk_widget_set_double_buffered (wfixed, FALSE);
gtk_window_set_wmclass (GTK_WINDOW (wtop),

1
src/lisp.h
View file

@ -3969,6 +3969,7 @@ extern _Noreturn void time_overflow (void);
extern Lisp_Object make_buffer_string (ptrdiff_t, ptrdiff_t, bool);
extern Lisp_Object make_buffer_string_both (ptrdiff_t, ptrdiff_t, ptrdiff_t,
ptrdiff_t, bool);
extern Lisp_Object styled_format (ptrdiff_t, Lisp_Object *, bool, bool);
extern void init_editfns (bool);
extern void syms_of_editfns (void);

28
src/nsterm.m
View file

@ -6520,7 +6520,7 @@ - (void)mouseDown: (NSEvent *)theEvent
/* FIXME: At the top or bottom of the buffer we should
* ignore momentum-phase events. */
if (! ns_touchpad_use_momentum
if (! ns_use_mwheel_momentum
&& [theEvent momentumPhase] != NSEventPhaseNone)
return;
@ -6529,8 +6529,8 @@ - (void)mouseDown: (NSEvent *)theEvent
static int totalDeltaX, totalDeltaY;
int lineHeight;
if (NUMBERP (ns_touchpad_scroll_line_height))
lineHeight = XINT (ns_touchpad_scroll_line_height);
if (NUMBERP (ns_mwheel_line_height))
lineHeight = XINT (ns_mwheel_line_height);
else
{
/* FIXME: Use actual line height instead of the default. */
@ -6571,7 +6571,7 @@ - (void)mouseDown: (NSEvent *)theEvent
totalDeltaX = 0;
}
if (lines > 1 && ! ns_use_system_mwheel_acceleration)
if (lines > 1 && ! ns_use_mwheel_acceleration)
lines = 1;
}
else
@ -6589,7 +6589,7 @@ - (void)mouseDown: (NSEvent *)theEvent
delta = [theEvent scrollingDeltaY];
}
lines = (ns_use_system_mwheel_acceleration)
lines = (ns_use_mwheel_acceleration)
? ceil (fabs (delta)) : 1;
scrollUp = delta > 0;
@ -9284,22 +9284,22 @@ Nil means use fullscreen the old (< 10.7) way. The old way works better with
This variable is ignored on Mac OS X < 10.7 and GNUstep. */);
ns_use_srgb_colorspace = YES;
DEFVAR_BOOL ("ns-use-system-mwheel-acceleration",
ns_use_system_mwheel_acceleration,
DEFVAR_BOOL ("ns-use-mwheel-acceleration",
ns_use_mwheel_acceleration,
doc: /*Non-nil means use macOS's standard mouse wheel acceleration.
This variable is ignored on macOS < 10.7 and GNUstep. Default is t. */);
ns_use_system_mwheel_acceleration = YES;
ns_use_mwheel_acceleration = YES;
DEFVAR_LISP ("ns-touchpad-scroll-line-height", ns_touchpad_scroll_line_height,
doc: /*The number of pixels touchpad scrolling considers a line.
DEFVAR_LISP ("ns-mwheel-line-height", ns_mwheel_line_height,
doc: /*The number of pixels touchpad scrolling considers one line.
Nil or a non-number means use the default frame line height.
This variable is ignored on macOS < 10.7 and GNUstep. Default is nil. */);
ns_touchpad_scroll_line_height = Qnil;
ns_mwheel_line_height = Qnil;
DEFVAR_BOOL ("ns-touchpad-use-momentum", ns_touchpad_use_momentum,
doc: /*Non-nil means touchpad scrolling uses momentum.
DEFVAR_BOOL ("ns-use-mwheel-momentum", ns_use_mwheel_momentum,
doc: /*Non-nil means mouse wheel scrolling uses momentum.
This variable is ignored on macOS < 10.7 and GNUstep. Default is t. */);
ns_touchpad_use_momentum = YES;
ns_use_mwheel_momentum = YES;
/* TODO: move to common code */
DEFVAR_LISP ("x-toolkit-scroll-bars", Vx_toolkit_scroll_bars,

2
src/w32term.c
View file

@ -6252,6 +6252,7 @@ w32fullscreen_hook (struct frame *f)
if (FRAME_PREV_FSMODE (f) == FULLSCREEN_BOTH)
{
if (!FRAME_UNDECORATED (f))
SetWindowLong (hwnd, GWL_STYLE, dwStyle | WS_OVERLAPPEDWINDOW);
SetWindowPlacement (hwnd, &FRAME_NORMAL_PLACEMENT (f));
}
@ -6278,6 +6279,7 @@ w32fullscreen_hook (struct frame *f)
w32_fullscreen_rect (hwnd, f->want_fullscreen,
FRAME_NORMAL_PLACEMENT (f).rcNormalPosition, &rect);
if (!FRAME_UNDECORATED (f))
SetWindowLong (hwnd, GWL_STYLE, dwStyle & ~WS_OVERLAPPEDWINDOW);
SetWindowPos (hwnd, HWND_TOP, rect.left, rect.top,
rect.right - rect.left, rect.bottom - rect.top,

4
src/xdisp.c
View file

@ -10194,7 +10194,7 @@ vadd_to_log (char const *format, va_list ap)
for (ptrdiff_t i = 1; i <= nargs; i++)
args[i] = va_arg (ap, Lisp_Object);
Lisp_Object msg = Qnil;
msg = Fformat_message (nargs, args);
msg = styled_format (nargs, args, true, false);
ptrdiff_t len = SBYTES (msg) + 1;
USE_SAFE_ALLOCA;
@ -19525,7 +19525,7 @@ DEFUN ("trace-to-stderr", Ftrace_to_stderr, Strace_to_stderr, 1, MANY, "",
usage: (trace-to-stderr STRING &rest OBJECTS) */)
(ptrdiff_t nargs, Lisp_Object *args)
{
Lisp_Object s = Fformat (nargs, args);
Lisp_Object s = styled_format (nargs, args, false, false);
fwrite (SDATA (s), 1, SBYTES (s), stderr);
return Qnil;
}

9
test/lisp/emacs-lisp/subr-x-tests.el
View file

@ -397,9 +397,14 @@
(should (equal 1 (let ((x 1)) (and-let* (x)))))
(should (equal nil (and-let* ((x nil)))))
(should (equal 1 (and-let* ((x 1)))))
(should-error (and-let* (nil (x 1))) :type 'setting-constant)
;; The error doesn't trigger when compiled: the compiler will give
;; a warning and then drop the erroneous code. Therefore, use
;; `eval' to avoid compilation.
(should-error (eval '(and-let* (nil (x 1))) lexical-binding)
:type 'setting-constant)
(should (equal nil (and-let* ((nil) (x 1)))))
(should-error (and-let* (2 (x 1))) :type 'wrong-type-argument)
(should-error (eval (and-let* (2 (x 1))) lexical-binding)
:type 'wrong-type-argument)
(should (equal 1 (and-let* ((2) (x 1)))))
(should (equal 2 (and-let* ((x 1) (2)))))
(should (equal nil (let ((x nil)) (and-let* (x) x))))

15
test/lisp/net/tramp-tests.el
View file

@ -2653,8 +2653,9 @@ This tests also `make-symbolic-link', `file-truename' and `add-name-to-file'."
(tmp-name1 (tramp--test-make-temp-name nil quoted))
(tmp-name2 (tramp--test-make-temp-name nil quoted))
(tmp-name3 (tramp--test-make-temp-name 'local quoted))
(tmp-name4 (tramp--test-make-temp-name nil quoted)))
(tmp-name4 (tramp--test-make-temp-name nil quoted))
(tmp-name5
(expand-file-name (file-name-nondirectory tmp-name1) tmp-name4)))
;; Check `make-symbolic-link'.
(unwind-protect
(tramp--test-ignore-make-symbolic-link-error
@ -2716,9 +2717,11 @@ This tests also `make-symbolic-link', `file-truename' and `add-name-to-file'."
(funcall
(if quoted 'tramp-compat-file-name-unquote 'identity)
(file-remote-p tmp-name1 'localname))
(file-symlink-p
(expand-file-name
(file-name-nondirectory tmp-name1) tmp-name4)))))
(file-symlink-p tmp-name5)))
;; `smbclient' does not show symlinks in directories, so
;; we cannot delete a non-empty directory. We delete the
;; file explicitely.
(delete-file tmp-name5))
;; Cleanup.
(ignore-errors
@ -2737,7 +2740,7 @@ This tests also `make-symbolic-link', `file-truename' and `add-name-to-file'."
(should-error
(add-name-to-file tmp-name1 tmp-name2)
:type 'file-already-exists)
;; number means interactive case.
;; A number means interactive case.
(cl-letf (((symbol-function 'yes-or-no-p) 'ignore))
(should-error
(add-name-to-file tmp-name1 tmp-name2 0)

21
test/lisp/textmodes/css-mode-tests.el
View file

@ -80,6 +80,27 @@
(equal (seq-sort #'string-lessp (css--value-class-lookup 'position))
'("bottom" "calc()" "center" "left" "right" "top"))))
(ert-deftest css-test-current-defun-name ()
(with-temp-buffer
(insert "body { top: 0; }")
(goto-char 7)
(should (equal (css-current-defun-name) "body"))
(goto-char 18)
(should (equal (css-current-defun-name) "body"))))
(ert-deftest css-test-current-defun-name-nested ()
(with-temp-buffer
(insert "body > .main a { top: 0; }")
(goto-char 20)
(should (equal (css-current-defun-name) "body > .main a"))))
(ert-deftest css-test-current-defun-name-complex ()
(with-temp-buffer
(insert "input[type=submit]:hover { color: red; }")
(goto-char 30)
(should (equal (css-current-defun-name)
"input[type=submit]:hover"))))
;;; Completion
(defun css-mode-tests--completions ()

3
test/lisp/xdg-tests.el
View file

@ -40,9 +40,6 @@
(should (equal (gethash "Name" tab1) "Test"))
(should (eq 'default (gethash "Exec" tab1 'default)))
(should (equal "frobnicate" (gethash "Exec" tab2))))
(should-error
(xdg-desktop-read-file
(expand-file-name "wrong.desktop" xdg-tests-data-dir)))
(should-error
(xdg-desktop-read-file
(expand-file-name "malformed.desktop" xdg-tests-data-dir)))