+2011-04-22 Juanma Barranquero <lekktu@gmail.com>
+
+ Lexical-binding cleanup.
+
+ * progmodes/ada-mode.el (ada-after-change-function, ada-loose-case-word)
+ (ada-no-auto-case, ada-capitalize-word, ada-untab, ada-narrow-to-defun):
+ * progmodes/ada-prj.el (ada-prj-initialize-values)
+ (ada-prj-display-page, ada-prj-field-modified, ada-prj-display-help)
+ (ada-prj-show-value):
+ * progmodes/ada-xref.el (ada-find-any-references, ada-gdb-application):
+ * progmodes/antlr-mode.el (antlr-with-displaying-help-buffer)
+ (antlr-invalidate-context-cache, antlr-options-menu-filter)
+ (antlr-language-option-extra, antlr-c++-mode-extra, antlr-run-tool):
+ * progmodes/bug-reference.el (bug-reference-push-button):
+ * progmodes/fortran.el (fortran-line-length):
+ * progmodes/glasses.el (glasses-change):
+ * progmodes/octave-mod.el (octave-fill-paragraph):
+ * progmodes/python.el (python-mode, python-pdbtrack-track-stack-file)
+ (python-pdbtrack-grub-for-buffer, python-sentinel):
+ * progmodes/sql.el (sql-save-connection):
+ * progmodes/tcl.el (tcl-indent-command, tcl-popup-menu):
+ * progmodes/xscheme.el (xscheme-enter-debugger-mode):
+ Mark unused parameters.
+
+ * progmodes/compile.el (compilation--flush-directory-cache)
+ (compilation--flush-parse, compile-internal): Mark unused parameters.
+ (compilation-buffer-name): Rename parameter MODE-NAME to NAME-OF-MODE.
+ (compilation-next-error-function): Remove unused variable `timestamp'.
+
+ * progmodes/cpp.el (cpp-parse-close): Remove unused variable `begin'.
+ (cpp-signal-read-only, cpp-grow-overlay): Mark unused parameters.
+
+ * progmodes/dcl-mode.el (dcl-end-of-command):
+ Remove unused variable `start'.
+ (dcl-calc-command-indent-multiple, dcl-calc-cont-indent-relative)
+ (dcl-option-value-basic, dcl-option-value-offset)
+ (dcl-option-value-margin-offset, dcl-option-value-comment-line):
+ Mark unused parameters.
+ (dcl-save-local-variable): Remove unused variable `val'.
+ (mode): Declare.
+
+ * progmodes/delphi.el (delphi-save-state, delphi-after-change):
+ Mark unused parameters.
+ (delphi-ignore-changes): Move before first use.
+ (delphi-charset-token-at): Remove unused variable `start'.
+ (delphi-else-start): Remove unused variable `if-count'.
+ (delphi-comment-block-start, delphi-comment-block-end):
+ Remove unused variable `kind'.
+ (delphi-indent-line): Remove unused variable `new-point'.
+
+ * progmodes/ebrowse.el (ebrowse-files-list)
+ (ebrowse-list-of-matching-members, ebrowse-tags-list-members-in-file):
+ Mark unused parameters. Don't quote `lambda'.
+ (ebrowse-sort-tree-list, ebrowse-same-tree-member-buffer-list):
+ Don't quote `lambda'.
+ (ebrowse-revert-tree-buffer-from-file, ebrowse-tags-choose-class)
+ (ebrowse-goto-visible-member/all-member-lists): Mark unused parameters.
+ (ebrowse-create-tree-buffer): Rename parameter OBARRAY to CLASSES.
+ (ebrowse-toggle-mark-at-point): Remove unused variable `pnt'.
+ Use `ignore-errors'.
+ (ebrowse-frozen-tree-buffer-name, ebrowse-find-source-file)
+ (ebrowse-view/find-file-and-search-pattern)
+ (ebrowse-view/find-member-declaration/definition):
+ Rename parameter TAGS-FILE-NAME to TAGS-FILE.
+ (ebrowse-find-class-declaration, ebrowse-view-class-declaration):
+ Rename parameter PREFIX-ARG to PREFIX.
+ (ebrowse-tags-read-name): Remove unused variables `start' and
+ `member-info'.
+ (ebrowse-display-member-buffer): Rename variable `tags-file-name'
+ to `tags-file'.
+
+ * progmodes/etags.el (local-find-tag-hook): Declare.
+ (tag-partial-file-name-match-p, tag-any-match-p, list-tags):
+ Mark unused parameters.
+
+ * progmodes/executable.el (compilation-error-regexp-alist): Declare.
+ (executable-interpret): Mark unused parameter.
+
+ * progmodes/flymake.el (flymake-process-sentinel)
+ (flymake-after-change-function)
+ (flymake-create-temp-with-folder-structure)
+ (flymake-get-include-dirs-dot): Mark unused parameters.
+ (flymake-safe-delete-directory): Remove unused variable `err'.
+
+ * progmodes/gdb-mi.el (speedbar-change-initial-expansion-list)
+ (speedbar-timer-fn, speedbar-line-text)
+ (speedbar-change-expand-button-char, speedbar-delete-subblock)
+ (speedbar-center-buffer-smartly): Declare functions.
+ (gdb-find-watch-expression): Remove unused variable `array'.
+ (gdb-edit-value, gdb-gdb, gdb-ignored-notification, gdb-thread-created)
+ (gdb-starting): Mark unused parameters.
+ (gud-gdbmi-marker-filter): Remove unused variable `output-record'.
+ (gdb-table-string): Remove unused variable `res'.
+ (gdb-place-breakpoints): Remove unused variables `flag' and `bptno'.
+ (gdb-disassembly-handler-custom): Remove unused variable `pos'.
+ (gdb-display-buffer): Remove unused variable `cur-size'.
+
+ * progmodes/gud.el (gud-def): Use `defalias' instead of `defun' to
+ allow lexical-binding compilation.
+ (gud-expansion-speedbar-buttons, gud-gdb-goto-stackframe)
+ (gud-dbx-massage-args, gud-xdb-massage-args, gud-perldb-massage-args)
+ (gud-jdb-massage-args, gud-jdb-find-source, gud-find-class):
+ Mark unused parameters.
+ (gud-gdb-marker-filter): Remove unused variable `match'.
+ (gud-find-class): Bind `syntax-symbol' and `syntax-point' to suitable
+ lambda expressions and funcall them, instead of using `fset'.
+
+ * progmodes/hideif.el (hif-parse-if-exp): Rename parameter
+ HIF-TOKEN-LIST to TOKEN-LIST and let-bind `hif-token-list'.
+
+ * progmodes/hideshow.el (hs-hide-block-at-point): Remove unused
+ variable `header-beg'; use `let'.
+
+ * progmodes/icon.el (indent-icon-exp): Remove unused variables
+ `restart', `last-sexp' and `at-do'.
+
+ * progmodes/js.el (js--debug): Mark unused parameter.
+ (js--parse-state-at-point): Remove unused variable `bound'; use `let'.
+ (js--splice-into-items): Remove unused variable `item'.
+ (js--read-symbol, js--read-tab): Pass 1/-1 to `ido-mode', not t/nil.
+
+ * progmodes/make-mode.el (makefile-make-font-lock-keywords):
+ Rename parameter FONT-LOCK-KEYWORDS to FL-KEYWORDS.
+ (makefile-complete): Remove unused variable `try'.
+ (makefile-fill-paragraph, makefile-match-function-end):
+ Mark unused parameters.
+
+ * progmodes/octave-inf.el (inferior-octave-complete):
+ Remove unused variable `proc'.
+ (inferior-octave-output-digest): Mark unused parameter.
+
+ * progmodes/perl-mode.el (perl-calculate-indent):
+ Remove unused variable `err'.
+
+ * progmodes/prolog.el (prolog-mode-keybindings-inferior)
+ (prolog-indent-line): Mark unused parameters.
+ (prolog-indent-line): Remove unused variable `beg'.
+
+ * progmodes/ps-mode.el (reporter-prompt-for-summary-p)
+ (reporter-dont-compact-list): Declare.
+
+ * progmodes/sh-script.el (sh-font-lock-quoted-subshell):
+ Remove unused variable `char'.
+ (sh-debug): Mark unused parameter.
+ (sh-get-indent-info): Remove unused variable `start'.
+ (sh-calculate-indent): Remove unused variable `var'.
+
+ * progmodes/simula.el (simula-popup-menu): Mark unused parameter.
+ (simula-electric-keyword): Remove unused variable `null'.
+ (simula-search-backward, simula-search-forward): Remove unused
+ variables `begin' and `end'.
+
+ * progmodes/vera-mode.el (vera-guess-basic-syntax):
+ Remove unused variable `pos'.
+ (vera-electric-tab, vera-comment-uncomment-region):
+ Mark unused parameters.
+ (vera-electric-tab): Rename parameter PREFIX-ARG to PREFIX.
+
2011-04-22 Chong Yidong <cyd@stupidchicken.com>
* emacs-lisp/package.el (package--builtins, package-alist)
(unless modified
(restore-buffer-modified-p nil))))
-(defun ada-after-change-function (beg end old-len)
+(defun ada-after-change-function (beg end _old-len)
"Called when the region between BEG and END was changed in the buffer.
OLD-LEN indicates what the length of the replaced text was."
(save-excursion
'( ?` ?_ ?# ?% ?& ?* ?( ?) ?- ?= ?+
?| ?\; ?: ?' ?\" ?< ?, ?. ?> ?/ ?\n 32 ?\r )))
-(defun ada-loose-case-word (&optional arg)
+(defun ada-loose-case-word (&optional _arg)
"Upcase first letter and letters following `_' in the following word.
No other letter is modified.
ARG is ignored, and is there for compatibility with `capitalize-word' only."
(insert-char (upcase (following-char)) 1)
(delete-char 1)))))
-(defun ada-no-auto-case (&optional arg)
+(defun ada-no-auto-case (&optional _arg)
"Do nothing. ARG is ignored.
This function can be used for the auto-casing variables in Ada mode, to
adapt to unusal auto-casing schemes. Since it does nothing, you can for
See also `ada-auto-case' to disable auto casing altogether."
nil)
-(defun ada-capitalize-word (&optional arg)
+(defun ada-capitalize-word (&optional _arg)
"Upcase first letter and letters following '_', lower case other letters.
ARG is ignored, and is there for compatibility with `capitalize-word' only."
(interactive)
((eq ada-tab-policy 'always-tab) (error "Not implemented"))
))
-(defun ada-untab (arg)
+(defun ada-untab (_arg)
"Delete leading indenting according to `ada-tab-policy'."
;; FIXME: ARG is ignored
(interactive "P")
;; Support for narrow-to-region
;; ---------------------------------------------------------
-(defun ada-narrow-to-defun (&optional arg)
+(defun ada-narrow-to-defun (&optional _arg)
"Make text outside current subprogram invisible.
The subprogram visible is the one that contains or follow point.
Optional ARG is ignored.
(ada-customize)
(ada-prj-new)))
-(defun ada-prj-initialize-values (symbol ada-buffer filename)
+(defun ada-prj-initialize-values (symbol _ada-buffer filename)
"Set SYMBOL to the property list of the project file FILENAME.
If FILENAME is null, read the file associated with ADA-BUFFER.
If no project file is found, return the default values."
(widget-insert "\n Project configuration.\n
___________ ____________ ____________ ____________ ____________\n / ")
(widget-create 'push-button :notify
- (lambda (&rest dummy) (ada-prj-display-page 1)) "General")
+ (lambda (&rest _dummy) (ada-prj-display-page 1)) "General")
(widget-insert " \\ / ")
(widget-create 'push-button :notify
- (lambda (&rest dummy) (ada-prj-display-page 2)) "Paths")
+ (lambda (&rest _dummy) (ada-prj-display-page 2)) "Paths")
(widget-insert " \\ / ")
(widget-create 'push-button :notify
- (lambda (&rest dummy) (ada-prj-display-page 3)) "Switches")
+ (lambda (&rest _dummy) (ada-prj-display-page 3)) "Switches")
(widget-insert " \\ / ")
(widget-create 'push-button :notify
- (lambda (&rest dummy) (ada-prj-display-page 4)) "Ada Menu")
+ (lambda (&rest _dummy) (ada-prj-display-page 4)) "Ada Menu")
(widget-insert " \\ / ")
(widget-create 'push-button :notify
- (lambda (&rest dummy) (ada-prj-display-page 5)) "Debugger")
+ (lambda (&rest _dummy) (ada-prj-display-page 5)) "Debugger")
(widget-insert " \\\n")
;; Display the currently selected page
(widget-insert "______________________________________________________________________\n\n ")
(widget-create 'push-button
- :notify (lambda (&rest ignore)
+ :notify (lambda (&rest _ignore)
(setq ada-prj-current-values (ada-default-prj-properties))
(ada-prj-display-page 1))
"Reset to Default Values")
(widget-insert " ")
- (widget-create 'push-button :notify (lambda (&rest ignore) (kill-buffer nil))
+ (widget-create 'push-button :notify (lambda (&rest _ignore) (kill-buffer nil))
"Cancel")
(widget-insert " ")
- (widget-create 'push-button :notify (lambda (&rest ignore) (ada-prj-save))
+ (widget-create 'push-button :notify (lambda (&rest _ignore) (ada-prj-save))
"Save")
(widget-insert "\n\n")
ada-list "\n"))
-(defun ada-prj-field-modified (widget &rest dummy)
+(defun ada-prj-field-modified (widget &rest _dummy)
"Callback for modification of WIDGET.
Remaining args DUMMY are ignored.
Save the change in `ada-prj-current-values' so that selecting
(widget-get widget ':prj-field)
(widget-value widget))))
-(defun ada-prj-display-help (widget widget-modified event)
+(defun ada-prj-display-help (widget _widget-modified event)
"Callback for help button in WIDGET.
Parameters WIDGET-MODIFIED, EVENT match :notify for the widget."
(let ((text (widget-get widget 'prj-help)))
(concat "*****Help*****\n" text "\n**************\n")
(point-at-bol 2)))))
-(defun ada-prj-show-value (widget widget-modified event)
+(defun ada-prj-show-value (widget _widget-modified event)
"Show the current field value in WIDGET.
Parameters WIDGET-MODIFIED, EVENT match :notify for the widget."
(let* ((field (widget-get widget ':prj-field))
(setq old-contents (buffer-string))))
(let ((compilation-error "reference"))
- (compilation-start command 'compilation-mode (lambda (mode) ada-gnatfind-buffer-name)))
+ (compilation-start command 'compilation-mode (lambda (_mode) ada-gnatfind-buffer-name)))
;; Hide the "Compilation" menu
(with-current-buffer ada-gnatfind-buffer-name
;; Do not add -fullname, since we can have a 'rsh' command in front.
;; FIXME: This is evil but luckily a nop under Emacs-21.3.50 ! -stef
- (fset 'gud-gdb-massage-args (lambda (file args) args))
+ (fset 'gud-gdb-massage-args (lambda (_file args) args))
(set 'pre-cmd (mapconcat 'identity pre-cmd ada-command-separator))
(if (not (equal pre-cmd ""))
;;; Code:
-(eval-when-compile
+(eval-when-compile
(require 'cl))
(require 'easymenu)
(declare-function cond-emacs-xemacs-macfn "antlr-mode" (args &optional msg))
;; General Emacs/XEmacs-compatibility compile-time macros
-(eval-when-compile
+(eval-when-compile
(defmacro cond-emacs-xemacs (&rest args)
(cond-emacs-xemacs-macfn
args "`cond-emacs-xemacs' must return exactly one element"))
(read-from-minibuffer prompt initial-input nil nil
(or history 'shell-command-history)))
-(defunx antlr-with-displaying-help-buffer (thunk &optional name)
+(defunx antlr-with-displaying-help-buffer (thunk &optional _name)
:xemacs-and-try with-displaying-help-buffer
"Make a help buffer and call `thunk' there."
(with-output-to-temp-buffer "*Help*"
;;;(defvar antlr-statistics-cache 0)
;;;(defvar antlr-statistics-inval 0)
-(defunx antlr-invalidate-context-cache (&rest dummies)
+(defunx antlr-invalidate-context-cache (&rest _dummies)
;; checkdoc-params: (dummies)
"Invalidate context cache for syntactical context information."
:XEMACS ; XEmacs bug workaround
table)))
(list level input (cdr kind))))))
-(defun antlr-options-menu-filter (level menu-items)
+(defun antlr-options-menu-filter (level _menu-items)
"Return items for options submenu of level LEVEL."
;; checkdoc-params: (menu-items)
(let ((active (if buffer-read-only
nil
table '(("false") ("true"))))
-(defun antlr-language-option-extra (phase &rest dummies)
+(defun antlr-language-option-extra (phase &rest _dummies)
;; checkdoc-params: (dummies)
"Change language according to the new value of the \"language\" option.
Call `antlr-mode' if the new language would be different from the value
(antlr-mode)
(and font-lock (null font-lock-mode) (font-lock-mode 1)))))))
-(defun antlr-c++-mode-extra (phase option &rest dummies)
+(defun antlr-c++-mode-extra (phase option &rest _dummies)
;; checkdoc-params: (option dummies)
"Warn if C++ option is used with the wrong language.
Ask user \(\"y or n\"), if a C++ only option is going to be inserted but
(or saved (save-some-buffers (not antlr-ask-about-save)))
(let ((default-directory (file-name-directory file)))
(compilation-start (concat command " " (file-name-nondirectory file))
- nil #'(lambda (mode-name) "*Antlr-Run*"))))
+ nil (lambda (_mode-name) "*Antlr-Run*"))))
(defun antlr-run-tool-interactive ()
;; code in `interactive' is not compiled
;; FIXME: Since it uses cc-mode, it bumps into c-update-modeline's
;; limitation to mode-name being a string.
;; '("Antlr." (:eval (cadr (assq antlr-language antlr-language-alist))))
- "Antlr"
+ "Antlr"
"Major mode for editing ANTLR grammar files."
:abbrev-table antlr-mode-abbrev-table
(c-initialize-cc-mode) ; cc-mode is required
"Keymap for Asm mode.")
(defconst asm-font-lock-keywords
- (append
+ (append
'(("^\\(\\(\\sw\\|\\s_\\)+\\)\\>:?[ \t]*\\(\\sw+\\(\\.\\sw+\\)*\\)?"
(1 font-lock-function-name-face) (3 font-lock-keyword-face nil t))
;; label started from ".".
(funcall bug-reference-url-format))))))))))
;; Taken from button.el.
-(defun bug-reference-push-button (&optional pos use-mouse-action)
+(defun bug-reference-push-button (&optional pos _use-mouse-action)
"Open URL corresponding to the bug reference at POS."
(interactive
(list (if (integerp last-command-event) (point) last-command-event)))
POS and RES.")
(make-variable-buffer-local 'compilation--previous-directory-cache)
-(defun compilation--flush-directory-cache (start end)
+(defun compilation--flush-directory-cache (start _end)
(cond
((or (not compilation--previous-directory-cache)
(<= (car compilation--previous-directory-cache) start)))
(compilation--parse-region (point) compilation--parsed)))))
nil)
-(defun compilation--flush-parse (start end)
+(defun compilation--flush-parse (start _end)
"Mark the region between START and END for re-parsing."
(if (markerp compilation--parsed)
(move-marker compilation--parsed (min start compilation--parsed))))
:group 'compilation)
-(defun compilation-buffer-name (mode-name mode-command name-function)
+(defun compilation-buffer-name (name-of-mode mode-command name-function)
"Return the name of a compilation buffer to use.
-If NAME-FUNCTION is non-nil, call it with one argument MODE-NAME
+If NAME-FUNCTION is non-nil, call it with one argument NAME-OF-MODE
to determine the buffer name.
Likewise if `compilation-buffer-name-function' is non-nil.
If current buffer has the major mode MODE-COMMAND,
return the name of the current buffer, so that it gets reused.
-Otherwise, construct a buffer name from MODE-NAME."
+Otherwise, construct a buffer name from NAME-OF-MODE."
(cond (name-function
- (funcall name-function mode-name))
+ (funcall name-function name-of-mode))
(compilation-buffer-name-function
- (funcall compilation-buffer-name-function mode-name))
+ (funcall compilation-buffer-name-function name-of-mode))
((eq mode-command major-mode)
(buffer-name))
(t
- (concat "*" (downcase mode-name) "*"))))
+ (concat "*" (downcase name-of-mode) "*"))))
;; This is a rough emulation of the old hack, until the transition to new
;; compile is complete.
(defun compile-internal (command error-message
- &optional name-of-mode parser
+ &optional _name-of-mode parser
error-regexp-alist name-function
- enter-regexp-alist leave-regexp-alist
- file-regexp-alist nomessage-regexp-alist
- no-async highlight-regexp local-map)
+ _enter-regexp-alist _leave-regexp-alist
+ file-regexp-alist _nomessage-regexp-alist
+ _no-async highlight-regexp _local-map)
(if parser
(error "Compile now works very differently, see `compilation-error-regexp-alist'"))
(let ((compilation-error-regexp-alist
(when reset
(setq compilation-current-error nil))
(let* ((columns compilation-error-screen-columns) ; buffer's local value
- (last 1) timestamp
+ (last 1)
(msg (compilation-next-error (or n 1) nil
(or compilation-current-error
compilation-messages-start
;; Pop top of cpp-state-stack and create overlay.
(let ((entry (assoc (nth 1 (car cpp-state-stack)) cpp-edit-list))
(branch (nth 0 (car cpp-state-stack)))
- (begin (nth 2 (car cpp-state-stack)))
(end (nth 3 (car cpp-state-stack))))
(setq cpp-state-stack (cdr cpp-state-stack))
(if entry
(overlay-put overlay 'insert-in-front-hooks '(cpp-grow-overlay))
(overlay-put overlay 'insert-behind-hooks '(cpp-grow-overlay)))
-(defun cpp-signal-read-only (overlay after start end &optional len)
+(defun cpp-signal-read-only (overlay after start end &optional _len)
;; Only allow deleting the whole overlay.
;; Trying to change a read-only overlay.
(if (and (not after)
(> (overlay-end overlay) end)))
(error "This text is read only")))
-(defun cpp-grow-overlay (overlay after start end &optional len)
+(defun cpp-grow-overlay (overlay after start end &optional _len)
;; Make OVERLAY grow to contain range START to END.
(if after
(move-overlay overlay
(defun dcl-end-of-command ()
"Move point to end of current command or next command if not on a command."
(interactive)
- (let ((type (dcl-get-line-type))
- (start (point)))
+ (let ((type (dcl-get-line-type)))
(if (or (eq type '$)
(eq type '-))
(progn
;;;---------------------------------------------------------------------------
(defun dcl-calc-command-indent-multiple
- (indent-type cur-indent extra-indent last-point this-point)
+ (indent-type cur-indent extra-indent _last-point _this-point)
"Indent lines to a multiple of dcl-basic-offset.
Set dcl-calc-command-indent-function to this function to customize
;;;---------------------------------------------------------------------------
-(defun dcl-calc-cont-indent-relative (cur-indent extra-indent)
+(defun dcl-calc-cont-indent-relative (_cur-indent _extra-indent)
"Indent continuation lines to align with words on previous line.
Indent continuation lines to a position relative to preceding
;;;-------------------------------------------------------------------------
-(defun dcl-option-value-basic (option-assoc)
+(defun dcl-option-value-basic (_option-assoc)
"Guess a value for basic-offset."
(save-excursion
(dcl-beginning-of-command)
;;;-------------------------------------------------------------------------
-(defun dcl-option-value-offset (option-assoc)
+(defun dcl-option-value-offset (_option-assoc)
"Guess a value for an offset.
Find the column of the first non-blank character on the line.
Returns the column offset."
;;;-------------------------------------------------------------------------
-(defun dcl-option-value-margin-offset (option-assoc)
+(defun dcl-option-value-margin-offset (_option-assoc)
"Guess a value for margin offset.
Find the column of the first non-blank character on the line, not
counting labels.
;;;-------------------------------------------------------------------------
-(defun dcl-option-value-comment-line (option-assoc)
+(defun dcl-option-value-comment-line (_option-assoc)
"Guess a value for `dcl-comment-line-regexp'.
Must return a string."
;; Should we set comment-start and comment-start-skip as well?
(if (eolp) (error "Missing colon in local variables entry"))
(skip-chars-backward " \t")
(let* ((str (buffer-substring beg (point)))
- (found-var (read str))
- val)
+ (found-var (read str)))
;; Setting variable named "end" means end of list.
(if (string-equal (downcase str) "end")
(progn
;;;-------------------------------------------------------------------------
+(with-no-warnings
+ ;; Dynamically bound in `dcl-save-mode'.
+ (defvar mode))
+
(defun dcl-save-mode ()
"Save the current mode for this buffer.
Save the current mode in a `Local Variables:'
(interactive)
(let ((mode (prin1-to-string major-mode)))
(if (string-match "-mode$" mode)
- (let ((mode (intern (substring mode 0 (match-beginning 0)))))
+ (let ((mode (intern (substring mode 0 (match-beginning 0)))))
(dcl-save-option 'mode))
(message "Strange mode: %s" mode))))
(after-change-functions nil)
(modified (buffer-modified-p)))
;; Disable any queries about editing obsolete files.
- (fset 'ask-user-about-supersession-threat (lambda (fn)))
+ (fset 'ask-user-about-supersession-threat (lambda (_fn)))
(unwind-protect
(progn ,@forms)
(set-buffer-modified-p modified)
(goto-char curr-point)
next))
+(defvar delphi-ignore-changes t
+ "Internal flag to control if the Delphi mode responds to buffer changes.
+Defaults to t in case the `delphi-after-change' function is called on a
+non-Delphi buffer. Set to nil in a Delphi buffer. To override, just do:
+ (let ((delphi-ignore-changes t)) ...)")
+
(defun delphi-set-text-properties (from to properties)
;; Like `set-text-properties', except we do not consider this to be a buffer
;; modification.
;; character set.
(let ((currp (point))
(end nil)
- (start nil)
(token nil))
(goto-char p)
(when (> (skip-chars-forward charset) 0)
(delphi-step-progress p "Fontifying" delphi-fontifying-progress-step))
(delphi-progress-done)))))
-(defvar delphi-ignore-changes t
- "Internal flag to control if the Delphi mode responds to buffer changes.
-Defaults to t in case the `delphi-after-change' function is called on a
-non-Delphi buffer. Set to nil in a Delphi buffer. To override, just do:
- (let ((delphi-ignore-changes t)) ...)")
-
-(defun delphi-after-change (change-start change-end old-length)
+(defun delphi-after-change (change-start change-end _old-length)
;; Called when the buffer has changed. Reparses the changed region.
(unless delphi-ignore-changes
(let ((delphi-ignore-changes t)) ; Prevent recursive calls.
;; Returns the token of the if or case statement.
(let ((token (delphi-previous-token from-else))
(token-kind nil)
- (semicolon-count 0)
- (if-count 0))
+ (semicolon-count 0))
(catch 'done
(while token
(setq token-kind (delphi-token-kind token))
comment
;; Scan until we run out of // comments.
(let ((prev-comment comment)
- (start-comment comment)
- (kind nil))
+ (start-comment comment))
(while (let ((kind (delphi-token-kind prev-comment)))
(cond ((eq kind 'space))
((eq kind 'comment-single-line)
comment
;; Scan until we run out of // comments.
(let ((next-comment comment)
- (end-comment comment)
- (kind nil))
+ (end-comment comment))
(while (let ((kind (delphi-token-kind next-comment)))
(cond ((eq kind 'space))
((eq kind 'comment-single-line)
(interactive)
(delphi-save-match-data
(let ((marked-point (point-marker)) ; Maintain our position reliably.
- (new-point nil)
(line-start nil)
(old-indent 0)
(new-indent 0))
"Return a list containing all files mentioned in a tree.
MARKED-ONLY non-nil means include marked classes only."
(let (list)
- (maphash #'(lambda (file dummy) (setq list (cons file list)))
+ (maphash (lambda (file _dummy) (setq list (cons file list)))
(ebrowse-files-table marked-only))
list))
(defun ebrowse-sort-tree-list (list)
"Sort a LIST of `ebrowse-ts' structures by qualified class names."
(sort list
- #'(lambda (a b)
- (string< (ebrowse-qualified-class-name (ebrowse-ts-class a))
- (ebrowse-qualified-class-name (ebrowse-ts-class b))))))
+ (lambda (a b)
+ (string< (ebrowse-qualified-class-name (ebrowse-ts-class a))
+ (ebrowse-qualified-class-name (ebrowse-ts-class b))))))
(defun ebrowse-class-in-tree (class tree)
(list header tree)))
-(defun ebrowse-revert-tree-buffer-from-file (ignore-auto-save noconfirm)
+(defun ebrowse-revert-tree-buffer-from-file (_ignore-auto-save noconfirm)
"Function installed as `revert-buffer-function' in tree buffers.
See that variable's documentation for the meaning of IGNORE-AUTO-SAVE and
NOCONFIRM."
(current-buffer)))
-(defun ebrowse-create-tree-buffer (tree tags-file header obarray pop)
+(defun ebrowse-create-tree-buffer (tree tags-file header classes pop)
"Create a new tree buffer for tree TREE.
The tree was loaded from file TAGS-FILE.
HEADER is the header structure of the file.
-OBARRAY is an obarray with a symbol for each class in the tree.
+CLASSES is an obarray with a symbol for each class in the tree.
POP non-nil means popup the buffer up at the end.
Return the buffer created."
(let ((name ebrowse-tree-buffer-name))
(ebrowse-tree-mode)
(setq ebrowse--tree tree
ebrowse--tags-file-name tags-file
- ebrowse--tree-obarray obarray
+ ebrowse--tree-obarray classes
ebrowse--header header
ebrowse--frozen-flag nil)
(ebrowse-redraw-tree)
"Toggle mark for class cursor is on.
If given a numeric N-TIMES argument, mark that many classes."
(interactive "p")
- (let (to-change pnt)
+ (let (to-change)
;; Get the classes whose mark must be toggled. Note that
;; ebrowse-tree-at-point might issue an error.
- (condition-case error
- (loop repeat (or n-times 1)
- as tree = (ebrowse-tree-at-point)
- do (progn
- (setf (ebrowse-ts-mark tree) (not (ebrowse-ts-mark tree)))
- (forward-line 1)
- (push tree to-change)))
- (error nil))
+ (ignore-errors
+ (loop repeat (or n-times 1)
+ as tree = (ebrowse-tree-at-point)
+ do (progn
+ (setf (ebrowse-ts-mark tree) (not (ebrowse-ts-mark tree)))
+ (forward-line 1)
+ (push tree to-change))))
(save-excursion
;; For all these classes, reverse the mark char in the display
;; by a regexp replace over the whole buffer. The reason for this
(defun ebrowse-same-tree-member-buffer-list ()
"Return a list of members buffers with same tree as current buffer."
(ebrowse-delete-if-not
- #'(lambda (buffer)
- (eq (ebrowse-value-in-buffer 'ebrowse--tree buffer)
- ebrowse--tree))
+ (lambda (buffer)
+ (eq (ebrowse-value-in-buffer 'ebrowse--tree buffer)
+ ebrowse--tree))
(ebrowse-member-buffer-list)))
when (eq class tree) do (kill-buffer buffer)))
-(defun ebrowse-frozen-tree-buffer-name (tags-file-name)
- "Return the buffer name of a tree which is associated TAGS-FILE-NAME."
- (concat ebrowse-tree-buffer-name " (" tags-file-name ")"))
+(defun ebrowse-frozen-tree-buffer-name (tags-file)
+ "Return the buffer name of a tree which is associated TAGS-FILE."
+ (concat ebrowse-tree-buffer-name " (" tags-file ")"))
(defun ebrowse-pop-to-browser-buffer (arg)
where)))
-(defun ebrowse-find-class-declaration (prefix-arg)
+(defun ebrowse-find-class-declaration (prefix)
"Find a class declaration and position cursor on it.
-PREFIX-ARG 4 means find it in another window.
-PREFIX-ARG 5 means find it in another frame."
+PREFIX 4 means find it in another window.
+PREFIX 5 means find it in another frame."
(interactive "p")
(ebrowse-view/find-class-declaration
:view nil
- :where (cond ((= prefix-arg 4) 'other-window)
- ((= prefix-arg 5) 'other-frame)
- (t 'this-window))))
+ :where (cond ((= prefix 4) 'other-window)
+ ((= prefix 5) 'other-frame)
+ (t 'this-window))))
-(defun ebrowse-view-class-declaration (prefix-arg)
+(defun ebrowse-view-class-declaration (prefix)
"View class declaration and position cursor on it.
-PREFIX-ARG 4 means view it in another window.
-PREFIX-ARG 5 means view it in another frame."
+PREFIX 4 means view it in another window.
+PREFIX 5 means view it in another frame."
(interactive "p")
(ebrowse-view/find-class-declaration
:view 'view
- :where (cond ((= prefix-arg 4) 'other-window)
- ((= prefix-arg 5) 'other-frame)
- (t 'this-window))))
+ :where (cond ((= prefix 4) 'other-window)
+ ((= prefix 5) 'other-frame)
+ (t 'this-window))))
\f
;;; The FIND engine
-(defun ebrowse-find-source-file (file tags-file-name)
+(defun ebrowse-find-source-file (file tags-file)
"Find source file FILE.
-Source files are searched for (a) relative to TAGS-FILE-NAME
+Source files are searched for (a) relative to TAGS-FILE
which is the path of the BROWSE file from which the class tree was loaded,
and (b) in the directories named in `ebrowse-search-path'."
(let (file-name
(try-file (expand-file-name file
- (file-name-directory tags-file-name))))
+ (file-name-directory tags-file))))
(if (file-readable-p try-file)
(setq file-name try-file)
(let ((search-in ebrowse-search-path))
'ebrowse-view-exit-fn)))
(defun ebrowse-view/find-file-and-search-pattern
- (struc info file tags-file-name &optional view where)
+ (struc info file tags-file &optional view where)
"Find or view a member or class.
STRUC is an `ebrowse-bs' structure (or a structure including that)
describing what to search.
FILE is the file to search the member in.
FILE is not taken out of STRUC here because the filename in STRUC
may be nil in which case the filename of the class description is used.
-TAGS-FILE-NAME is the name of the BROWSE file from which the
+TAGS-FILE is the name of the BROWSE file from which the
tree was loaded.
If VIEW is non-nil, view file else find the file.
WHERE is either `other-window', `other-frame' or `this-window' and
(error "Sorry, no file information available for %s"
(ebrowse-bs-name struc)))
;; Get the source file to view or find.
- (setf file (ebrowse-find-source-file file tags-file-name))
+ (setf file (ebrowse-find-source-file file tags-file))
;; If current window is dedicated, use another frame.
(when (window-dedicated-p (selected-window))
(setf where 'other-window))
(defun* ebrowse-view/find-member-declaration/definition
- (prefix view &optional definition info header tags-file-name)
+ (prefix view &optional definition info header tags-file)
"Find or view a member declaration or definition.
With PREFIX 4. find file in another window, with prefix 5
find file in another frame.
declaration.
INFO is a list (TREE ACCESSOR MEMBER) describing the member to
search.
-TAGS-FILE-NAME is the file name of the BROWSE file."
+TAGS-FILE is the file name of the BROWSE file."
(unless header
(setq header ebrowse--header))
- (unless tags-file-name
- (setq tags-file-name ebrowse--tags-file-name))
+ (unless tags-file
+ (setq tags-file ebrowse--tags-file-name))
(let (tree member accessor file on-class
(where (if (= prefix 4) 'other-window
(if (= prefix 5) 'other-frame 'this-window))))
(ebrowse-ts-class tree)
(list ebrowse--header (ebrowse-ts-class tree) nil)
(ebrowse-cs-file (ebrowse-ts-class tree))
- tags-file-name view where)))
+ tags-file view where)))
;; For some member lists, it doesn't make sense to search for
;; a definition. If this is requested, silently search for the
;; declaration.
(message nil)
;; Recurse with new info.
(ebrowse-view/find-member-declaration/definition
- prefix view (not definition) info header tags-file-name))
+ prefix view (not definition) info header tags-file))
(error "Search canceled"))
;; Find that thing.
(ebrowse-view/find-file-and-search-pattern
:point (ebrowse-ms-point member))
(list header member accessor)
file
- tags-file-name
+ tags-file
view
where))))
means the member buffer is standalone. CLASS is its class."
(let* ((classes ebrowse--tree-obarray)
(tree ebrowse--tree)
- (tags-file-name ebrowse--tags-file-name)
+ (tags-file ebrowse--tags-file-name)
(header ebrowse--header)
temp-buffer-setup-hook
(temp-buffer (get-buffer ebrowse-member-buffer-name)))
ebrowse--accessor list
ebrowse--tree-obarray classes
ebrowse--frozen-flag stand-alone
- ebrowse--tags-file-name tags-file-name
+ ebrowse--tags-file-name tags-file
ebrowse--header header
ebrowse--tree tree
buffer-read-only t)
\f
;;; Switching member buffer to display a selected member
-(defun ebrowse-goto-visible-member/all-member-lists (prefix)
+(defun ebrowse-goto-visible-member/all-member-lists (_prefix)
"Position cursor on a member read from the minibuffer.
With PREFIX, search all members in the tree. Otherwise consider
only members visible in the buffer."
Prompt with PROMPT. Insert into the minibuffer a C++ identifier read
from point as default. Value is a list (CLASS-NAME MEMBER-NAME)."
(save-excursion
- (let* (start member-info (members (ebrowse-member-table header)))
+ (let ((members (ebrowse-member-table header)))
(multiple-value-bind (class-name member-name)
(values-list (ebrowse-tags-read-member+class-name))
(unless member-name
(completion-result (try-completion name members)))
;; Cannot rely on `try-completion' returning t for exact
;; matches! It returns the name as a string.
- (unless (setq member-info (gethash name members))
+ (unless (gethash name members)
(if (y-or-n-p "No exact match found. Try substrings? ")
(setq name
(or (first (ebrowse-list-of-matching-members
(list class name))))
-(defun ebrowse-tags-choose-class (tree header name initial-class-name)
+(defun ebrowse-tags-choose-class (_tree header name initial-class-name)
"Read a class name for a member from the minibuffer.
TREE is the class tree we operate on.
HEADER is its header structure.
info)
(unless name
(multiple-value-setq (class-name name)
- (values-list
+ (values-list
(ebrowse-tags-read-name
header
(concat (if view "View" "Find") " member "
(let* ((marker (point-marker)) class-name (name fix-name) info)
(unless name
(multiple-value-setq (class-name name)
- (values-list
+ (values-list
(ebrowse-tags-read-name header
(concat "Find member list of: ")))))
(setq info (ebrowse-tags-choose-class tree header name class-name))
are not performed."
(let (list)
(when (or name regexp)
- (maphash #'(lambda (member-name info)
- (when (or (and name (string= name member-name))
- (and regexp (string-match regexp member-name)))
- (setq list (cons member-name list))))
+ (maphash (lambda (member-name _info)
+ (when (or (and name (string= name member-name))
+ (and regexp (string-match regexp member-name)))
+ (setq list (cons member-name list))))
members))
list))
(with-output-to-temp-buffer (concat "*Members in file " file "*")
(set-buffer standard-output)
(maphash
- #'(lambda (member-name list)
- (loop for info in list
- as member = (third info)
- as class = (ebrowse-ts-class (first info))
- when (or (and (null (ebrowse-ms-file member))
- (string= (ebrowse-cs-file class) file))
- (string= file (ebrowse-ms-file member)))
- do (ebrowse-draw-file-member-info info "decl.")
- when (or (and (null (ebrowse-ms-definition-file member))
- (string= (ebrowse-cs-source-file class) file))
- (string= file (ebrowse-ms-definition-file member)))
- do (ebrowse-draw-file-member-info info "defn.")))
+ (lambda (_member-name list)
+ (loop for info in list
+ as member = (third info)
+ as class = (ebrowse-ts-class (first info))
+ when (or (and (null (ebrowse-ms-file member))
+ (string= (ebrowse-cs-file class) file))
+ (string= file (ebrowse-ms-file member)))
+ do (ebrowse-draw-file-member-info info "decl.")
+ when (or (and (null (ebrowse-ms-definition-file member))
+ (string= (ebrowse-cs-source-file class) file))
+ (string= file (ebrowse-ms-definition-file member)))
+ do (ebrowse-draw-file-member-info info "defn.")))
members))))
(defun initialize-new-tags-table ()
"Initialize the tags table in the current buffer.
Return non-nil if it is a valid tags table, and
-in that case, also make the tags table state variables
+in that case, also make the tags table state variables
buffer-local and set them to nil."
(set (make-local-variable 'tags-table-files) nil)
(set (make-local-variable 'tags-completion-table) nil)
;; Dynamic bondage:
(defvar etags-case-fold-search)
(defvar etags-syntax-table)
+(defvar local-find-tag-hook)
;;;###autoload
(defun find-tag-noselect (tagname &optional next-p regexp-p)
;; partial file name match, i.e. searched tag must match a substring
;; of the file name (potentially including a directory separator).
-(defun tag-partial-file-name-match-p (tag)
+(defun tag-partial-file-name-match-p (_tag)
"Return non-nil if current tag matches file name.
This is a substring match, and it can include directory separators.
Point should be just after a string that matches TAG."
(looking-at "\f\n"))))
;; t if point is in a tag line with a tag containing TAG as a substring.
-(defun tag-any-match-p (tag)
+(defun tag-any-match-p (_tag)
"Return non-nil if current tag line contains TAG as a substring."
(looking-at ".*\177"))
(try-completion string (tags-table-files) predicate))))
;;;###autoload
-(defun list-tags (file &optional next-match)
+(defun list-tags (file &optional _next-match)
"Display list of tags in file FILE.
This searches only the first table in the list, and no included tables.
FILE should be as it appeared in the `etags' command, usually without a
(file-modes buffer-file-name)))))))
+(defvar compilation-error-regexp-alist) ; from compile.el
+
;;;###autoload
(defun executable-interpret (command)
"Run script with user-specified args, and collect output in a buffer.
(save-some-buffers (not compilation-ask-about-save))
(set (make-local-variable 'executable-command) command)
(let ((compilation-error-regexp-alist executable-error-regexp-alist))
- (compilation-start command t (lambda (x) "*interpretation*"))))
+ (compilation-start command t (lambda (_x) "*interpretation*"))))
(with-current-buffer source-buffer
(flymake-parse-output-and-residual output)))))
-(defun flymake-process-sentinel (process event)
+(defun flymake-process-sentinel (process _event)
"Sentinel for syntax check buffers."
(when (memq (process-status process) '(signal exit))
(let* ((exit-status (process-exit-status process))
(flymake-log 1 "deleted file %s" file-name)))
(defun flymake-safe-delete-directory (dir-name)
- (condition-case err
+ (condition-case nil
(progn
(delete-directory dir-name)
(flymake-log 1 "deleted dir %s" dir-name))
:group 'flymake
:type 'boolean)
-(defun flymake-after-change-function (start stop len)
+(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" (flymake-float-time))
(let((new-text (buffer-substring start stop)))
(flymake-log 3 "create-temp-inplace: file=%s temp=%s" file-name temp-name)
temp-name))
-(defun flymake-create-temp-with-folder-structure (file-name prefix)
+(defun flymake-create-temp-with-folder-structure (file-name _prefix)
(unless (stringp file-name)
(error "Invalid file-name"))
(when temp-master-file-name
(flymake-get-tex-args temp-master-file-name))))
-(defun flymake-get-include-dirs-dot (base-dir)
+(defun flymake-get-include-dirs-dot (_base-dir)
'("."))
;;;; xml-specific init-cleanup routines
:type 'integer
:safe 'integerp
:initialize 'custom-initialize-default
- :set (lambda (symbol value)
+ :set (lambda (_symbol value)
;; Do all fortran buffers, and the default.
(fortran-line-length value t))
:version "23.1"
(require 'bindat)
(eval-when-compile (require 'cl))
+(declare-function speedbar-change-initial-expansion-list "speedbar" (new-default))
+(declare-function speedbar-timer-fn "speedbar" ())
+(declare-function speedbar-line-text "speedbar" (&optional p))
+(declare-function speedbar-change-expand-button-char "speedbar" (char))
+(declare-function speedbar-delete-subblock "speedbar" (indent))
+(declare-function speedbar-center-buffer-smartly "speedbar" ())
+
(defvar tool-bar-map)
(defvar speedbar-initial-expansion-list-name)
(defvar speedbar-frame)
(defun gdb-find-watch-expression ()
(let* ((var (nth (- (line-number-at-pos (point)) 2) gdb-var-list))
- (varnum (car var)) expr array)
+ (varnum (car var)) expr)
(string-match "\\(var[0-9]+\\)\\.\\(.*\\)" varnum)
(let ((var1 (assoc (match-string 1 varnum) gdb-var-list)) var2 varnumlet
(component-list (split-string (match-string 2 varnum) "\\." t)))
(gdb-input
(list (concat "-var-delete -c " varnum) 'ignore)))
-(defun gdb-edit-value (text token indent)
+(defun gdb-edit-value (_text _token _indent)
"Assign a value to a variable displayed in the speedbar."
(let* ((var (nth (- (count-lines (point-min) (point)) 2) gdb-var-list))
(varnum (car var)) (value))
;; Start accumulating output for the GUD buffer
(setq gdb-filter-output "")
- (let ((output-record) (output-record-list))
+ (let (output-record-list)
;; Process all the complete markers in this chunk.
(dolist (gdbmi-record gdbmi-record-list)
gdb-filter-output))
-(defun gdb-gdb (output-field))
+(defun gdb-gdb (_output-field))
(defun gdb-shell (output-field)
(let ((gdb-output-sink gdb-output-sink))
(setq gdb-filter-output
(concat output-field gdb-filter-output))))
-(defun gdb-ignored-notification (output-field))
+(defun gdb-ignored-notification (_output-field))
;; gdb-invalidate-threads is defined to accept 'update-threads signal
-(defun gdb-thread-created (output-field))
+(defun gdb-thread-created (_output-field))
(defun gdb-thread-exited (output-field)
"Handle =thread-exited async record: unset `gdb-thread-number'
if current thread exited and update threads list."
(setq gdb-active-process t)
(gdb-emit-signal gdb-buf-publisher 'update-threads))
-(defun gdb-starting (output-field)
+(defun gdb-starting (_output-field)
;; CLI commands don't emit ^running at the moment so use gdb-running too.
(setq gdb-inferior-status "running")
(gdb-force-mode-line-update
(defun gdb-table-string (table &optional sep)
"Return TABLE as a string with columns separated with SEP."
- (let ((column-sizes (gdb-table-column-sizes table))
- (res ""))
+ (let ((column-sizes (gdb-table-column-sizes table)))
(mapconcat
'identity
(gdb-mapcar*
;; Put breakpoint icons in relevant margins (even those set in the GUD buffer).
(defun gdb-place-breakpoints ()
- (let ((flag) (bptno))
- ;; Remove all breakpoint-icons in source buffers but not assembler buffer.
- (dolist (buffer (buffer-list))
- (with-current-buffer buffer
- (if (and (eq gud-minor-mode 'gdbmi)
- (not (string-match "\\` ?\\*.+\\*\\'" (buffer-name))))
- (gdb-remove-breakpoint-icons (point-min) (point-max)))))
- (dolist (breakpoint gdb-breakpoints-list)
- (let* ((breakpoint (cdr breakpoint)) ; gdb-breakpoints-list is
- ; an associative list
- (line (bindat-get-field breakpoint 'line)))
- (when line
- (let ((file (bindat-get-field breakpoint 'fullname))
- (flag (bindat-get-field breakpoint 'enabled))
- (bptno (bindat-get-field breakpoint 'number)))
- (unless (file-exists-p file)
- (setq file (cdr (assoc bptno gdb-location-alist))))
- (if (and file
- (not (string-equal file "File not found")))
- (with-current-buffer
- (find-file-noselect file 'nowarn)
- (gdb-init-buffer)
- ;; Only want one breakpoint icon at each location.
- (gdb-put-breakpoint-icon (string-equal flag "y") bptno
- (string-to-number line)))
- (gdb-input
- (list (concat "list " file ":1")
- 'ignore))
- (gdb-input
- (list "-file-list-exec-source-file"
- `(lambda () (gdb-get-location
- ,bptno ,line ,flag)))))))))))
+ ;; Remove all breakpoint-icons in source buffers but not assembler buffer.
+ (dolist (buffer (buffer-list))
+ (with-current-buffer buffer
+ (if (and (eq gud-minor-mode 'gdbmi)
+ (not (string-match "\\` ?\\*.+\\*\\'" (buffer-name))))
+ (gdb-remove-breakpoint-icons (point-min) (point-max)))))
+ (dolist (breakpoint gdb-breakpoints-list)
+ (let* ((breakpoint (cdr breakpoint)) ; gdb-breakpoints-list is
+ ; an associative list
+ (line (bindat-get-field breakpoint 'line)))
+ (when line
+ (let ((file (bindat-get-field breakpoint 'fullname))
+ (flag (bindat-get-field breakpoint 'enabled))
+ (bptno (bindat-get-field breakpoint 'number)))
+ (unless (file-exists-p file)
+ (setq file (cdr (assoc bptno gdb-location-alist))))
+ (if (and file
+ (not (string-equal file "File not found")))
+ (with-current-buffer
+ (find-file-noselect file 'nowarn)
+ (gdb-init-buffer)
+ ;; Only want one breakpoint icon at each location.
+ (gdb-put-breakpoint-icon (string-equal flag "y") bptno
+ (string-to-number line)))
+ (gdb-input
+ (list (concat "list " file ":1")
+ 'ignore))
+ (gdb-input
+ (list "-file-list-exec-source-file"
+ `(lambda () (gdb-get-location
+ ,bptno ,line ,flag))))))))))
(defvar gdb-source-file-regexp "fullname=\"\\(.*?\\)\"")
(defun gdb-disassembly-handler-custom ()
(let* ((instructions (bindat-get-field (gdb-json-partial-output) 'asm_insns))
(address (bindat-get-field (gdb-current-buffer-frame) 'addr))
- (pos 1)
(table (make-gdb-table))
(marked-line nil))
(dolist (instr instructions)
(let ((window (get-lru-window)))
(if (eq (buffer-local-value 'gud-minor-mode (window-buffer window))
'gdbmi)
- (let* ((largest (get-largest-window))
- (cur-size (window-height largest)))
+ (let ((largest (get-largest-window)))
(setq answer (split-window largest))
(set-window-buffer answer buf)
(set-window-dedicated-p answer dedicated)
nil)
-(defun glasses-change (beg end &optional old-len)
+(defun glasses-change (beg end &optional _old-len)
"After-change function updating glass overlays."
(let ((beg-line (save-excursion (goto-char beg) (line-beginning-position)))
(end-line (save-excursion (goto-char end) (line-end-position))))
source file) or the source line number at the last break or step (if
we're in the GUD buffer)."
`(progn
- (defun ,func (arg)
+ (defalias ',func (lambda (arg)
,@(if doc (list doc))
(interactive "p")
(if (not gud-running)
,(if (stringp cmd)
`(gud-call ,cmd arg)
- cmd)))
+ cmd))))
,(if key `(local-set-key ,(concat "\C-c" key) ',func))
,(if key `(global-set-key (vconcat gud-key-prefix ,key) ',func))))
(gud-install-speedbar-variables)
(add-hook 'speedbar-load-hook 'gud-install-speedbar-variables))
-(defun gud-expansion-speedbar-buttons (directory zero)
+(defun gud-expansion-speedbar-buttons (_directory _zero)
"Wrapper for call to `speedbar-add-expansion-list'.
DIRECTORY and ZERO are not used, but are required by the caller."
(gud-speedbar-buttons gud-comint-buffer))
gud-marker-acc (substring gud-marker-acc (match-end 0))))
(while (string-match "\n\032\032\\(.*\\)\n" gud-marker-acc)
- (let ((match (match-string 1 gud-marker-acc)))
-
- (setq
- ;; Append any text before the marker to the output we're going
- ;; to return - we don't include the marker in this text.
- output (concat output
- (substring gud-marker-acc 0 (match-beginning 0)))
+ (setq
+ ;; Append any text before the marker to the output we're going
+ ;; to return - we don't include the marker in this text.
+ output (concat output
+ (substring gud-marker-acc 0 (match-beginning 0)))
- ;; Set the accumulator to the remaining text.
+ ;; Set the accumulator to the remaining text.
- gud-marker-acc (substring gud-marker-acc (match-end 0)))))
+ gud-marker-acc (substring gud-marker-acc (match-end 0))))
;; Does the remaining text look like it might end with the
;; beginning of another marker? If it does, then keep it in
;; gdb speedbar functions
-(defun gud-gdb-goto-stackframe (text token indent)
+(defun gud-gdb-goto-stackframe (_text token _indent)
"Goto the stackframe described by TEXT, TOKEN, and INDENT."
(speedbar-with-attached-buffer
(gud-basic-call (concat "server frame " (nth 1 token)))
directory))
:group 'gud)
-(defun gud-dbx-massage-args (file args)
+(defun gud-dbx-massage-args (_file args)
(nconc (let ((directories gud-dbx-directories)
(result nil))
(while directories
directory))
:group 'gud)
-(defun gud-xdb-massage-args (file args)
+(defun gud-xdb-massage-args (_file args)
(nconc (let ((directories gud-xdb-directories)
(result nil))
(while directories
;; History of argument lists passed to perldb.
(defvar gud-perldb-history nil)
-(defun gud-perldb-massage-args (file args)
+(defun gud-perldb-massage-args (_file args)
"Convert a command line as would be typed normally to run perldb
into one that invokes an Emacs-enabled debugging session.
\"-emacs\" is inserted where it will be $ARGV[0] (see perl5db.pl)."
;; Change what was given in the minibuffer to something that can be used to
;; invoke the debugger.
-(defun gud-jdb-massage-args (file args)
+(defun gud-jdb-massage-args (_file args)
;; The jdb executable must have whitespace between "-classpath" and
;; its value while gud-common-init expects all switch values to
;; follow the switch keyword without intervening whitespace. We
(setq cplist (cdr cplist)))
(if found-file (concat (car cplist) "/" filename)))))
-(defun gud-jdb-find-source (string)
+(defun gud-jdb-find-source (_string)
"Alias for function used to locate source files.
Set to `gud-jdb-find-source-using-classpath' or `gud-jdb-find-source-file'
during jdb initialization depending on the value of
(declare-function syntax-symbol "gud" (x))
(declare-function syntax-point "gud" (x))
-(defun gud-find-class (f line)
+(defun gud-find-class (f _line)
"Find fully qualified class in file F at line LINE.
This function uses the `gud-jdb-classpath' (and optional
`gud-jdb-sourcepath') list(s) to derive a file
(save-match-data
(let ((cplist (append gud-jdb-sourcepath gud-jdb-classpath))
(fbuffer (get-file-buffer f))
- syntax-symbol syntax-point class-found)
+ class-found
+ ;; Syntax-symbol returns the symbol of the *first* element
+ ;; in the syntactical analysis result list, syntax-point
+ ;; returns the buffer position of same
+ (syntax-symbol (lambda (x) (c-langelem-sym (car x))))
+ (syntax-point (lambda (x) (c-langelem-pos (car x)))))
(setq f (file-name-sans-extension (file-truename f)))
- ;; Syntax-symbol returns the symbol of the *first* element
- ;; in the syntactical analysis result list, syntax-point
- ;; returns the buffer position of same
- (fset 'syntax-symbol (lambda (x) (c-langelem-sym (car x))))
- (fset 'syntax-point (lambda (x) (c-langelem-pos (car x))))
;; Search through classpath list for an entry that is
;; contained in f
(while (and cplist (not class-found))
;; with the 'topmost-intro symbol, there may be
;; nested classes...
(while (not (eq 'topmost-intro
- (syntax-symbol (c-guess-basic-syntax))))
+ (funcall syntax-symbol (c-guess-basic-syntax))))
;; Check if the current position c-syntactic
;; analysis has 'inclass
(setq syntax (c-guess-basic-syntax))
(while
- (and (not (eq 'inclass (syntax-symbol syntax)))
+ (and (not (eq 'inclass (funcall syntax-symbol syntax)))
(cdr syntax))
(setq syntax (cdr syntax)))
- (if (eq 'inclass (syntax-symbol syntax))
+ (if (eq 'inclass (funcall syntax-symbol syntax))
(progn
- (goto-char (syntax-point syntax))
+ (goto-char (funcall syntax-point syntax))
;; Now we're at the beginning of a class
;; definition. Find class name
(looking-at
(append (list (match-string-no-properties 1))
nclass)))
(setq syntax (c-guess-basic-syntax))
- (while (and (not (syntax-point syntax)) (cdr syntax))
+ (while (and (not (funcall syntax-point syntax)) (cdr syntax))
(setq syntax (cdr syntax)))
- (goto-char (syntax-point syntax))
+ (goto-char (funcall syntax-point syntax))
))
(string-match (concat (car nclass) "$") class-found)
(setq class-found
"Pop the next token from token-list into the let variable \"hif-token\"."
(setq hif-token (pop hif-token-list)))
-(defun hif-parse-if-exp (hif-token-list)
+(defun hif-parse-if-exp (token-list)
"Parse the TOKEN-LIST. Return translated list in prefix form."
- (hif-nexttoken)
- (prog1
- (hif-expr)
- (if hif-token ; is there still a token?
- (error "Error: unexpected token: %s" hif-token))))
+ (let ((hif-token-list token-list))
+ (hif-nexttoken)
+ (prog1
+ (hif-expr)
+ (if hif-token ; is there still a token?
+ (error "Error: unexpected token: %s" hif-token)))))
(defun hif-expr ()
"Parse an expression as found in #if.
;; Unary plus/minus.
((memq hif-token '(hif-minus hif-plus))
(list (prog1 hif-token (hif-nexttoken)) 0 (hif-factor)))
-
+
(t ; identifier
(let ((ident hif-token))
(if (memq ident '(or and))
(if comment-reg
(hs-hide-comment-region (car comment-reg) (cadr comment-reg) end)
(when (looking-at hs-block-start-regexp)
- (let* ((mdata (match-data t))
- (header-beg (match-beginning 0))
- (header-end (match-end 0))
- p q ov)
+ (let ((mdata (match-data t))
+ (header-end (match-end 0))
+ p q ov)
;; `p' is the point at the end of the block beginning, which
;; may need to be adjusted
(save-excursion
(let ((indent-stack (list nil))
(contain-stack (list (point)))
(case-fold-search nil)
- restart outer-loop-done inner-loop-done state ostate
- this-indent last-sexp last-depth
- at-else at-brace at-do
+ outer-loop-done inner-loop-done state ostate
+ this-indent last-depth
+ at-else at-brace
(opoint (point))
(next-depth 0))
(save-excursion
(setq state (parse-partial-sexp (point) (progn (end-of-line) (point))
nil nil state))
(setq next-depth (car state))
- (if (and (car (cdr (cdr state)))
- (>= (car (cdr (cdr state))) 0))
- (setq last-sexp (car (cdr (cdr state)))))
(if (or (nth 4 ostate))
(icon-indent-line))
(if (or (nth 3 state))
(setq outer-loop-done t))
(if outer-loop-done
nil
- (if (/= last-depth next-depth)
- (setq last-sexp nil))
(while (> last-depth next-depth)
(setq indent-stack (cdr indent-stack)
contain-stack (cdr contain-stack)
(setq beg (or beg (save-restriction (widen) (point-min))))
(setq js--cache-end (min js--cache-end beg)))
-(defmacro js--debug (&rest arguments)
+(defmacro js--debug (&rest _arguments)
;; `(message ,@arguments)
)
(save-restriction
(widen)
(js--ensure-cache)
- (let* ((bound (if (eobp) (point) (1+ (point))))
- (pstate (or (save-excursion
- (js--backward-pstate))
- (list js--initial-pitem))))
+ (let ((pstate (or (save-excursion
+ (js--backward-pstate))
+ (list js--initial-pitem))))
;; Loop until we either hit a pitem at BOB or pitem ends after
;; point (or at point if we're at eob)
(let ((top-name (car name-parts))
(item-ptr items)
- new-items last-new-item new-cons item)
+ new-items last-new-item new-cons)
(js--debug "js--splice-into-items: name-parts: %S items:%S"
name-parts
. LOCATION), where SYMBOL-NAME is a string and LOCATION is a
marker."
(unless ido-mode
- (ido-mode t)
- (ido-mode nil))
+ (ido-mode 1)
+ (ido-mode -1))
(let ((choice (ido-completing-read
prompt
;; Prime IDO
(unless ido-mode
- (ido-mode t)
- (ido-mode nil))
+ (ido-mode 1)
+ (ido-mode -1))
(with-js
(lexical-let ((tabs (js--get-tabs)) selected-tab-cname
(defun makefile-make-font-lock-keywords (var keywords space
&optional negation
- &rest font-lock-keywords)
+ &rest fl-keywords)
`(;; Do macro assignments. These get the "variable-name" face.
(,makefile-macroassign-regex
(1 font-lock-variable-name-face)
;; They can make a tab fail to be effective.
("^\\( +\\)\t" 1 makefile-space)))
- ,@font-lock-keywords
+ ,@fl-keywords
;; Do dependencies.
(makefile-match-dependency
'("^[ \t]*\\.for[ \t].+[ \t]\\(in\\)\\>" 1 font-lock-keyword-face)))
(defconst makefile-imake-font-lock-keywords
- (append
+ (append
(makefile-make-font-lock-keywords
makefile-var-use-regex
makefile-statements
(let* ((beg (save-excursion
(skip-chars-backward "^$(){}:#= \t\n")
(point)))
- (try (buffer-substring beg (point)))
(paren nil)
(do-macros
(save-excursion
;; Filling
-(defun makefile-fill-paragraph (arg)
+(defun makefile-fill-paragraph (_arg)
;; Fill comments, backslashed lines, and variable definitions
;; specially.
(save-excursion
;;; Utility functions
;;; ------------------------------------------------------------
-(defun makefile-match-function-end (end)
+(defun makefile-match-function-end (_end)
"To be called as an anchored matcher by font-lock.
The anchor must have matched the opening parens in the first group."
(let ((s (match-string-no-properties 1)))
(command
(save-excursion
(skip-syntax-backward "w_" (comint-line-beginning-position))
- (buffer-substring-no-properties (point) end)))
- (proc (get-buffer-process inferior-octave-buffer)))
+ (buffer-substring-no-properties (point) end))))
(cond (inferior-octave-complete-impossible
(error (concat
"Your Octave does not have `completion_matches'. "
the rest to `comint-output-filter'."
(comint-output-filter proc (inferior-octave-strip-ctrl-g string)))
-(defun inferior-octave-output-digest (proc string)
+(defun inferior-octave-output-digest (_proc string)
"Special output filter for the inferior Octave process.
Save all output between newlines into `inferior-octave-output-list', and
the rest to `inferior-octave-output-string'."
(setq give-up t))))
(not give-up))))
-(defun octave-fill-paragraph (&optional arg)
+(defun octave-fill-paragraph (&optional _arg)
"Fill paragraph of Octave code, handling Octave comments."
;; FIXME: difference with generic fill-paragraph:
;; - code lines are only split, never joined.
;; );
(progn
(skip-syntax-backward "(")
- (condition-case err
+ (condition-case nil
(while (save-excursion
(skip-syntax-backward " ") (not (bolp)))
(forward-sexp -1))
(define-key map "\C-c\C-l" 'prolog-consult-file)
(define-key map "\C-c\C-z" 'switch-to-prolog))
-(defun prolog-mode-keybindings-inferior (map)
+(defun prolog-mode-keybindings-inferior (_map)
"Define keybindings for inferior Prolog mode in MAP."
;; No inferior mode specific keybindings now.
)
;; NB: This function *MUST* have this optional argument since XEmacs
;; assumes it. This does not mean we have to use it...
-(defun prolog-indent-line (&optional whole-exp)
+(defun prolog-indent-line (&optional _whole-exp)
"Indent current line as Prolog code.
With argument, indent any additional lines of the same clause
rigidly along with this one (not yet)."
(interactive "p")
(let ((indent (prolog-indent-level))
- (pos (- (point-max) (point))) beg)
+ (pos (- (point-max) (point))))
(beginning-of-line)
- (setq beg (point))
(skip-chars-forward " \t")
(indent-line-to indent)
(if (> (- (point-max) pos) (point))
(interactive)
(message " *** PostScript Mode (ps-mode) Version %s *** " ps-mode-version))
+;; From reporter.el
+(defvar reporter-prompt-for-summary-p)
+(defvar reporter-dont-compact-list)
+
(defun ps-mode-submit-bug-report ()
"Submit via mail a bug report on PostScript mode."
(interactive)
;; doesn't seem to work properly.
(add-to-list 'hs-special-modes-alist
`(python-mode "^\\s-*\\(?:def\\|class\\)\\>" nil "#"
- ,(lambda (arg)
+ ,(lambda (_arg)
(python-end-of-defun)
(skip-chars-backward " \t\n"))
nil))
(setq overlay-arrow-position nil
python-pdbtrack-is-tracking-p nil)))
-(defun python-pdbtrack-track-stack-file (text)
+(defun python-pdbtrack-track-stack-file (_text)
"Show the file indicated by the pdb stack entry line, in a separate window.
Activity is disabled if the buffer-local variable
)
)
-(defun python-pdbtrack-grub-for-buffer (funcname lineno)
- "Find recent python-mode buffer named, or having function named funcname."
+(defun python-pdbtrack-grub-for-buffer (funcname _lineno)
+ "Find recent Python mode buffer named, or having function named FUNCNAME."
(let ((buffers (buffer-list))
buf
got)
(interactive)
(python-pdbtrack-toggle-stack-tracking 0))
-(defun python-sentinel (proc msg)
+(defun python-sentinel (_proc _msg)
(setq overlay-arrow-position nil))
(provide 'python)
;; rather flakey.
(when (eq ?\" (nth 3 (syntax-ppss))) ; Check we matched an opening quote.
;; bingo we have a $( or a ` inside a ""
- (let ((char (char-after (point)))
- ;; `state' can be: double-quote, backquote, code.
+ (let (;; `state' can be: double-quote, backquote, code.
(state (if (eq (char-before) ?`) 'backquote 'code))
;; Stacked states in the context.
(states '(double-quote)))
;; "For debugging: display message ARGS if variable SH-DEBUG is non-nil."
;; (if sh-debug
;; (apply 'message args)))
-(defmacro sh-debug (&rest args))
+(defmacro sh-debug (&rest _args))
(defconst sh-symbol-list
'((const :tag "+ " :value +
(save-excursion
(let ((have-result nil)
this-kw
- start
val
(result nil)
(align-point nil)
;; We start off at beginning of this line.
;; Scan previous statements while this is <=
;; start of previous line.
- (setq start (point)) ;; for debug only
(goto-char prev-line-end)
(setq x t)
(while (and x (setq x (sh-prev-thing)))
If INFO is supplied it is used, else it is calculated from current line."
(let ((ofs 0)
(base-value 0)
- elt a b var val)
+ elt a b val)
(or info
(setq info (sh-get-indent-info)))
(when info
"Keymap used in `simula-mode'.")
;; menus for Lucid
-(defun simula-popup-menu (e)
+(defun simula-popup-menu (_e)
"Pops up the SIMULA menu."
(interactive "@e")
(popup-menu (cons (concat mode-name " Mode Commands") simula-mode-menu)))
((eq simula-abbrev-keyword 'downcase) (downcase-word -1))
((eq simula-abbrev-keyword 'capitalize) (capitalize-word -1)))
(let ((pos (- (point-max) (point)))
- (case-fold-search t)
- null)
- (condition-case null
+ (case-fold-search t))
+ (condition-case nil
(progn
;; check if the expanded word is on the beginning of the line.
(if (and (eq (char-syntax (preceding-char)) ?w)
The match found must not extend after that position. Optional third argument
NOERROR, if t, means if fail just return nil (no error).
If not nil and not t, move to limit of search and return nil."
- (let (begin end context (comb-regexp (concat regexp "\\|\\<end\\>"))
- match (start-point (point)))
+ (let ((comb-regexp (concat regexp "\\|\\<end\\>"))
+ (start-point (point))
+ context match)
(catch 'simula-backward
(while (re-search-backward comb-regexp bound 1)
;; We have a match, check SIMULA context at match-beginning
The match found must not extend after that position. Optional third argument
NOERROR, if t, means if fail just return nil (no error).
If not nil and not t, move to limit of search and return nil."
- (let (begin end context (comb-regexp (concat regexp "\\|\\<begin\\>"))
- match (start-point (point)))
+ (let ((comb-regexp (concat regexp "\\|\\<begin\\>"))
+ (start-point (point))
+ context match)
(catch 'simula-forward
(while (re-search-forward comb-regexp bound 1)
;; We have a match, check SIMULA context at match-beginning
(append (list name)
(sql-for-each-login
`(product ,@login)
- (lambda (token plist)
+ (lambda (token _plist)
(cond
((eq token 'product) `(sql-product ',sql-product))
((eq token 'user) `(sql-user ,sql-user))
\f
-(defun tcl-indent-command (&optional arg)
+(defun tcl-indent-command (&optional _arg)
"Indent current line as Tcl code, or in some cases insert a tab character.
If `tcl-tab-always-indent' is t (the default), always indent current line.
If `tcl-tab-always-indent' is nil and point is not in the indentation
;; loading the XEmacs menu emulation code.
;;
-(defun tcl-popup-menu (e)
+(defun tcl-popup-menu (_e)
(interactive "@e")
(popup-menu tcl-mode-menu))
-;;; vera-mode.el --- major mode for editing Vera files.
+;;; vera-mode.el --- major mode for editing Vera files
;; Copyright (C) 1997-2011 Free Software Foundation, Inc.
(save-excursion
(beginning-of-line)
(let ((indent-point (point))
- syntax state placeholder pos)
+ syntax state placeholder)
;; determine syntax state
(setq state (parse-partial-sexp (point-min) (point)))
(cond
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; electrifications
-(defun vera-electric-tab (&optional prefix-arg)
+(defun vera-electric-tab (&optional prefix)
"Do what I mean (indent, expand, tab, change indent, etc..).
If preceding character is part of a word or a paren then `hippie-expand',
else if right of non whitespace on line then `tab-to-tab-stop',
(or (and (boundp 'hippie-expand-only-buffers)
hippie-expand-only-buffers)
'(vera-mode))))
- (vera-expand-abbrev prefix-arg)))
+ (vera-expand-abbrev prefix)))
((> (current-column) (current-indentation))
(tab-to-tab-stop))
((and (or (eq last-command 'vera-electric-tab)
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; Comments
-(defun vera-comment-uncomment-region (beg end &optional arg)
+(defun vera-comment-uncomment-region (beg end &optional _arg)
"Comment region if not commented, uncomment region if already commented."
(interactive "r\nP")
(goto-char beg)
(interactive)
(xscheme-send-char last-command-event))
-(defun xscheme-enter-debugger-mode (prompt-string)
+(defun xscheme-enter-debugger-mode (_prompt-string)
(with-current-buffer (xscheme-process-buffer)
(if (not (derived-mode-p 'scheme-debugger-mode))
(progn
(xscheme-goto-output-point)
(let ((old-point (point)))
(while (string-match "\\(\007\\|\f\\)" string)
- (let ((start (match-beginning 0))
- (end (match-end 0)))
+ (let ((start (match-beginning 0)))
(insert-before-markers (substring string 0 start))
(if (= ?\f (aref string start))
(progn