Remove a few more redundant `:group` args.
Make use of lexical scoping to replace `(lambda...) with proper closures.
* lisp/cedet/ede/custom.el (ede-project-sort-targets-list):
Use `dotimes` and replace `(lambda..) with closures.
* lisp/cedet/ede/proj-comp.el (proj-comp-insert-variable-once):
* lisp/cedet/ede/pmake.el (ede-pmake-insert-variable-once):
Remove unused var `addcr`.
* lisp/cedet/semantic/complete.el: Use lexical-binding.
(semantic-displayer-show-request): Remove unused var `typing-count`.
Use `equal` instead of `stringp+string=`.
* lisp/cedet/semantic/db-ebrowse.el: Use lexical-binding.
(semanticdb-create-ebrowse-database): Remove unused vars `mma` and `regexp`.
(semanticdb-ebrowse-strip-trees): Remove unused var `class` and `filename`.
(semanticdb-ebrowse-add-globals-to-table): Remove unused var `fname`.
* lisp/cedet/semantic/db-find.el: Use lexical-binding.
(semanticdb-find-adebug-insert-scanned-tag-cons): Remove always-nil var
`tip`.
* lisp/cedet/semantic/db-global.el: Use lexical-binding.
(semanticdb-enable-gnu-global-databases): Access local var
`semantic--ih` by sticking its value in the code passed to `eval`
rather than by dynamic scoping.
* lisp/cedet/semantic/db-typecache.el: Use lexical-binding.
(semanticdb-db-typecache-dump): Remove unused var `junk`.
* lisp/cedet/semantic/debug.el: Use lexical-binding.
* lisp/cedet/semantic/dep.el: Use lexical-binding.
(semantic-add-system-include): Avoid `add-to-list` on a local variable.
Access local var `value` by sticking its value in the code passed to
`eval` rather than by dynamic scoping.
(semantic-remove-system-include): Don't use `delete` on a list received
from elsewhere.
Access local var `value` by sticking its value in the code passed to
`eval` rather than by dynamic scoping.
(semantic-reset-system-include): Simplify a bit.
* lisp/cedet/semantic/ede-grammar.el: Use lexical-binding.
(project-compile-target): Remove unused vars `csrc` and `cb`.
Use `cl-incf`. Remove apparently unneeded `with-no-warnings`.
* lisp/cedet/semantic/edit.el: Use lexical-binding.
(semantic-edits-change-over-tags): Remove unused var `inner-start`.
(semantic-edits-incremental-parser-1): Silence warnings about
intentionally unused var `last-cond`.
* lisp/cedet/semantic/fw.el: Use lexical-binding.
(recentf-exclude, semantic-init-hook, ede-auto-add-method)
(flymake-start-syntax-check-on-find-file, auto-insert): Declare vars.
* lisp/cedet/semantic/ia-sb.el: Use lexical-binding.
(semantic-ia-sb-key-map): Move initialization into declaration.
(semantic-ia-sb-more-buttons): Remove unused var `idx`.
(semantic-ia-sb-line-path): Simplify `if` -> `or`.
* lisp/cedet/semantic/idle.el (semantic-idle-breadcrumbs--tag-function):
Make it a function returning a closure.
* lisp/cedet/semantic/senator.el: Use lexical-binding.
(senator-search-set-tag-class-filter): Replace `(lambda..) with a closure.
* lisp/cedet/semantic/sort.el: Use lexical-binding.
(semanticdb-search-system-databases): Declare var.
(semantic-tag-external-member-children-default): Replace `(lambda..)
with a closure.
* lisp/cedet/semantic/tag-ls.el: Use lexical-binding.
(semantic-tag-protection-default, semantic-tag-abstract-p-default):
Simplify with `member`.
* lisp/cedet/semantic/util.el: Use lexical-binding.
(semantic-something-to-tag-table): Declare function
`semanticdb-abstract-table--eieio-childp` called via `cl-typep`.
* lisp/cedet/semantic/bovine/scm.el (semantic-default-scheme-setup):
Remove duplicate setting of `imenu-create-index-function`.
* lisp/cedet/semantic/decorate/mode.el (semantic-decoration-build-style-menu):
Replace `(lambda..) with a closure.
* lisp/cedet/srecode/cpp.el (srecode-semantic-apply-tag-to-dict):
Remove always-t variable `member`.
* lisp/cedet/srecode/mode.el (srecode-minor-mode-templates-menu):
Replace `(lambda..) with a closure. Use `push`.
* lisp/cedet/semantic/chart.el: Use lexical-binding.
* lisp/cedet/semantic/db-debug.el: Use lexical-binding.
* lisp/cedet/semantic/db-el.el: Use lexical-binding.
* lisp/cedet/semantic/db-file.el: Use lexical-binding.
* lisp/cedet/semantic/db-javascript.el: Use lexical-binding.
* lisp/cedet/semantic/db-mode.el: Use lexical-binding.
* lisp/cedet/semantic/db-ref.el: Use lexical-binding.
* lisp/cedet/semantic/decorate.el: Use lexical-binding.
* lisp/cedet/semantic/doc.el: Use lexical-binding.
* lisp/cedet/semantic/find.el: Use lexical-binding.
* lisp/cedet/semantic/format.el: Use lexical-binding.
* lisp/cedet/semantic/html.el: Use lexical-binding.
* lisp/cedet/semantic/ia.el: Use lexical-binding.
* lisp/cedet/semantic/imenu.el: Use lexical-binding.
* lisp/cedet/semantic/java.el: Use lexical-binding.
* lisp/cedet/semantic/mru-bookmark.el: Use lexical-binding.
* lisp/cedet/semantic/symref.el: Use lexical-binding.
* lisp/cedet/semantic/tag-file.el: Use lexical-binding.
* lisp/cedet/semantic/tag-write.el: Use lexical-binding.
* lisp/cedet/semantic/texi.el: Use lexical-binding.
* lisp/cedet/semantic/util-modes.el: Use lexical-binding.
;;; cedet-cscope.el --- CScope support for CEDET -*- lexical-binding: t; -*-
-;;; Copyright (C) 2009-2021 Free Software Foundation, Inc.
+;; Copyright (C) 2009-2021 Free Software Foundation, Inc.
;; Author: Eric M. Ludlam <zappo@gnu.org>
;; Package: cedet
(defun ede-project-sort-targets-list ()
"Sort the target list while using `ede-project-sort-targets'."
(save-excursion
- (let ((count 0)
- (targets (oref ede-object-project targets))
+ (let ((targets (oref ede-object-project targets))
(inhibit-read-only t)
(inhibit-modification-hooks t))
(goto-char (point-min))
(forward-line 2)
(delete-region (point) (point-max))
- (while (< count (length targets))
+ (dotimes (count (length targets))
(if (> count 0)
(widget-create 'push-button
- :notify `(lambda (&rest ignore)
- (let ((cur ede-project-sort-targets-order))
- (add-to-ordered-list
- 'ede-project-sort-targets-order
- (nth ,count cur)
- (1- ,count))
- (add-to-ordered-list
- 'ede-project-sort-targets-order
- (nth (1- ,count) cur) ,count))
- (ede-project-sort-targets-list))
+ :notify (lambda (&rest _ignore)
+ (let ((cur ede-project-sort-targets-order))
+ (add-to-ordered-list
+ 'ede-project-sort-targets-order
+ (nth count cur)
+ (1- count))
+ (add-to-ordered-list
+ 'ede-project-sort-targets-order
+ (nth (1- count) cur) count))
+ (ede-project-sort-targets-list))
" Up ")
(widget-insert " "))
(if (< count (1- (length targets)))
(widget-create 'push-button
- :notify `(lambda (&rest ignore)
- (let ((cur ede-project-sort-targets-order))
- (add-to-ordered-list
- 'ede-project-sort-targets-order
- (nth ,count cur) (1+ ,count))
- (add-to-ordered-list
- 'ede-project-sort-targets-order
- (nth (1+ ,count) cur) ,count))
- (ede-project-sort-targets-list))
+ :notify (lambda (&rest _ignore)
+ (let ((cur ede-project-sort-targets-order))
+ (add-to-ordered-list
+ 'ede-project-sort-targets-order
+ (nth count cur) (1+ count))
+ (add-to-ordered-list
+ 'ede-project-sort-targets-order
+ (nth (1+ count) cur) count))
+ (ede-project-sort-targets-list))
" Down ")
(widget-insert " "))
(widget-insert (concat " " (number-to-string (1+ count)) ".: "
(oref (nth (nth count ede-project-sort-targets-order)
targets)
name)
- "\n"))
- (setq count (1+ count))))))
+ "\n"))))))
;;; Customization hooks
;;
;;; ede/make.el --- General information about "make" -*- lexical-binding: t -*-
-;;; Copyright (C) 2009-2021 Free Software Foundation, Inc.
+;; Copyright (C) 2009-2021 Free Software Foundation, Inc.
;; Author: Eric M. Ludlam <zappo@gnu.org>
;;; ede/pconf.el --- configure.ac maintenance for EDE -*- lexical-binding: t; -*-
-;;; Copyright (C) 1998-2000, 2005, 2008-2021 Free Software Foundation,
-;;; Inc.
+;; Copyright (C) 1998-2021 Free Software Foundation, Inc.
;; Author: Eric M. Ludlam <zappo@gnu.org>
;; Keywords: project
"Add VARNAME into the current Makefile if it doesn't exist.
Execute BODY in a location where a value can be placed."
(declare (debug t) (indent 1))
- `(let ((addcr t) (v ,varname))
- (unless
- (save-excursion
- (re-search-backward (concat "^" v "\\s-*=") nil t))
- (insert v "=")
- ,@body
- (when addcr (insert "\n"))
- (goto-char (point-max)))))
+ `(let ((v ,varname))
+ (unless
+ (save-excursion
+ (re-search-backward (concat "^" v "\\s-*=") nil t))
+ (insert v "=")
+ ,@body
+ (insert "\n")
+ (goto-char (point-max)))))
;;; SOURCE VARIABLE NAME CONSTRUCTION
"Add VARNAME into the current Makefile if it doesn't exist.
Execute BODY in a location where a value can be placed."
(declare (indent 1) (debug (sexp body)))
- `(let ((addcr t) (v ,varname))
+ `(let ((v ,varname))
(unless (re-search-backward (concat "^" v "\\s-*=") nil t)
(insert v "=")
,@body
- (if addcr (insert "\n"))
- (goto-char (point-max)))
- ))
+ (insert "\n")
+ (goto-char (point-max)))))
(cl-defmethod ede-proj-makefile-insert-variables ((this ede-compilation-program))
"Insert variables needed by the compiler THIS."
;;; ede-proj-info.el --- EDE Generic Project texinfo support -*- lexical-binding: t; -*-
-;;; Copyright (C) 1998-2001, 2004, 2007-2021 Free Software Foundation,
-;;; Inc.
+;; Copyright (C) 1998-2021 Free Software Foundation, Inc.
;; Author: Eric M. Ludlam <zappo@gnu.org>
;; Keywords: project, make
;;; ede/proj-obj.el --- EDE Generic Project Object code generation support -*- lexical-binding: t; -*-
-;;; Copyright (C) 1998-2000, 2005, 2008-2021 Free Software Foundation,
-;;; Inc.
+;; Copyright (C) 1998-2021 Free Software Foundation, Inc.
;; Author: Eric M. Ludlam <zappo@gnu.org>
;; Keywords: project, make
;;; ede-proj-shared.el --- EDE Generic Project shared library support -*- lexical-binding: t; -*-
-;;; Copyright (C) 1998-2000, 2009-2021 Free Software Foundation, Inc.
+;; Copyright (C) 1998-2021 Free Software Foundation, Inc.
;; Author: Eric M. Ludlam <zappo@gnu.org>
;; Keywords: project, make
;;; semantic/analyze/debug.el --- Debug the analyzer -*- lexical-binding: t; -*-
-;;; Copyright (C) 2008-2021 Free Software Foundation, Inc.
+;; Copyright (C) 2008-2021 Free Software Foundation, Inc.
;; Author: Eric M. Ludlam <zappo@gnu.org>
(setq-local semantic-analyzer-debug-orig orig-buffer)
;; First, add do-in buttons to recommendations.
(while (re-search-forward "^\\s-*M-x \\(\\(\\w\\|\\s_\\)+\\) " nil t)
- (let ((fcn (match-string 1)))
- (when (not (fboundp (intern-soft fcn)))
+ (let* ((fcn (match-string 1))
+ (fsym (intern-soft fcn)))
+ (when (not (fboundp fsym))
(error "Help Err: Can't find %s" fcn))
(end-of-line)
(insert " ")
(insert-button "[ Do It ]"
'mouse-face 'custom-button-pressed-face
'do-fcn fcn
- 'action `(lambda (arg)
- (let ((M semantic-analyzer-debug-orig))
- (set-buffer (marker-buffer M))
- (goto-char M))
- (call-interactively (quote ,(intern-soft fcn))))))))
+ 'action (lambda (_arg)
+ (let ((M semantic-analyzer-debug-orig))
+ (set-buffer (marker-buffer M))
+ (goto-char M))
+ (call-interactively fsym))))))
;; Do something else?
;; Clean up the mess
(set-buffer-modified-p nil))))
;; but not actually parsed.
(file . "File"))
semantic-case-fold t
- semantic-tag-expand-function 'semantic-make-expand-tag
+ semantic-tag-expand-function #'semantic-make-expand-tag
semantic-lex-syntax-modifications '((?. "_")
(?= ".")
(?/ "_")
(?+ ".")
(?\\ ".")
)
- imenu-create-index-function 'semantic-create-imenu-index
+ imenu-create-index-function #'semantic-create-imenu-index
)
(setq semantic-lex-analyzer #'semantic-make-lexer)
)
;;; semantic/bovine/scm.el --- Semantic details for Scheme (guile) -*- lexical-binding: t; -*-
-;;; Copyright (C) 2001-2004, 2008-2021 Free Software Foundation, Inc.
+;; Copyright (C) 2001-2021 Free Software Foundation, Inc.
;; Author: Eric M. Ludlam <zappo@gnu.org>
(function . "Functions")
(include . "Loads")
(package . "DefineModule"))
- imenu-create-index-function 'semantic-create-imenu-index
- imenu-create-index-function 'semantic-create-imenu-index
+ imenu-create-index-function #'semantic-create-imenu-index
)
(setq semantic-lex-analyzer #'semantic-scheme-lexer)
)
-;;; semantic/chart.el --- Utilities for use with semantic tag tables
+;;; semantic/chart.el --- Utilities for use with semantic tag tables -*- lexical-binding: t; -*-
;; Copyright (C) 1999-2001, 2003, 2005, 2008-2021 Free Software
;; Foundation, Inc.
(interactive)
(let* ((stream (semantic-something-to-tag-table
(or tagtable (current-buffer))))
- (names (mapcar 'cdr semantic-symbol->name-assoc-list))
+ (names (mapcar #'cdr semantic-symbol->name-assoc-list))
(nums (mapcar
(lambda (symname)
(length
nums "Volume")
))
-(defun semantic-chart-database-size (&optional tagtable)
+(defun semantic-chart-database-size (&optional _tagtable)
"Create a bar chart representing the size of each file in semanticdb.
Each bar represents how many toplevel tags in TAGTABLE
exist in each database entry.
(error "Semanticdb is not enabled"))
(let* ((db semanticdb-current-database)
(dbt (semanticdb-get-database-tables db))
- (names (mapcar 'car
+ (names (mapcar #'car
(object-assoc-list
'file
dbt)))
(nums nil)
(fh (/ (- (frame-height) 7) 4)))
(setq numnuts (sort numnuts (lambda (a b) (> (car a) (car b)))))
- (setq names (mapcar 'cdr numnuts)
- nums (mapcar 'car numnuts))
+ (setq names (mapcar #'cdr numnuts)
+ nums (mapcar #'car numnuts))
(if (> (length names) fh)
(progn
(setcdr (nthcdr fh names) nil)
-;;; semantic/complete.el --- Routines for performing tag completion
+;;; semantic/complete.el --- Routines for performing tag completion -*- lexical-binding: t; -*-
;; Copyright (C) 2003-2005, 2007-2021 Free Software Foundation, Inc.
(defun semantic-completion-message (fmt &rest args)
"Display the string FMT formatted with ARGS at the end of the minibuffer."
(if semantic-complete-inline-overlay
- (apply 'message fmt args)
- (apply 'message (concat "%s" fmt) (buffer-string) args)))
+ (apply #'message fmt args)
+ (apply #'message (concat "%s" fmt) (buffer-string) args)))
;;; ------------------------------------------------------------
;;; MINIBUFFER: Option Selection harnesses
(defvar semantic-complete-key-map
(let ((km (make-sparse-keymap)))
- (define-key km " " 'semantic-complete-complete-space)
- (define-key km "\t" 'semantic-complete-complete-tab)
- (define-key km "\C-m" 'semantic-complete-done)
- (define-key km "\C-g" 'abort-recursive-edit)
- (define-key km "\M-n" 'next-history-element)
- (define-key km "\M-p" 'previous-history-element)
- (define-key km "\C-n" 'next-history-element)
- (define-key km "\C-p" 'previous-history-element)
+ (define-key km " " #'semantic-complete-complete-space)
+ (define-key km "\t" #'semantic-complete-complete-tab)
+ (define-key km "\C-m" #'semantic-complete-done)
+ (define-key km "\C-g" #'abort-recursive-edit)
+ (define-key km "\M-n" #'next-history-element)
+ (define-key km "\M-p" #'previous-history-element)
+ (define-key km "\C-n" #'next-history-element)
+ (define-key km "\C-p" #'previous-history-element)
;; Add history navigation
km)
"Keymap used while completing across a list of tags.")
)
(t nil))))
-(defun semantic-complete-do-completion (&optional partial inline)
+(defun semantic-complete-do-completion (&optional partial _inline)
"Do a completion for the current minibuffer.
If PARTIAL, do partial completion stopping at spaces.
if INLINE, then completion is happening inline in a buffer."
;; push ourselves out of this mode on alternate keypresses.
(defvar semantic-complete-inline-map
(let ((km (make-sparse-keymap)))
- (define-key km "\C-i" 'semantic-complete-inline-TAB)
- (define-key km "\M-p" 'semantic-complete-inline-up)
- (define-key km "\M-n" 'semantic-complete-inline-down)
- (define-key km "\C-m" 'semantic-complete-inline-done)
- (define-key km "\C-\M-c" 'semantic-complete-inline-exit)
- (define-key km "\C-g" 'semantic-complete-inline-quit)
+ (define-key km "\C-i" #'semantic-complete-inline-TAB)
+ (define-key km "\M-p" #'semantic-complete-inline-up)
+ (define-key km "\M-n" #'semantic-complete-inline-down)
+ (define-key km "\C-m" #'semantic-complete-inline-done)
+ (define-key km "\C-\M-c" #'semantic-complete-inline-exit)
+ (define-key km "\C-g" #'semantic-complete-inline-quit)
(define-key km "?"
(lambda () (interactive)
(describe-variable 'semantic-complete-inline-map)))
"Exit inline completion mode."
(interactive)
;; Remove this hook FIRST!
- (remove-hook 'pre-command-hook 'semantic-complete-pre-command-hook)
+ (remove-hook 'pre-command-hook #'semantic-complete-pre-command-hook)
(condition-case nil
(progn
;; Remove this hook LAST!!!
;; This will force us back through this function if there was
;; some sort of error above.
- (remove-hook 'post-command-hook 'semantic-complete-post-command-hook)
+ (remove-hook 'post-command-hook #'semantic-complete-post-command-hook)
;;(message "Exiting inline completion.")
)
(overlay-put semantic-complete-inline-overlay
'semantic-original-start start)
;; Install our command hooks
- (add-hook 'pre-command-hook 'semantic-complete-pre-command-hook)
- (add-hook 'post-command-hook 'semantic-complete-post-command-hook)
+ (add-hook 'pre-command-hook #'semantic-complete-pre-command-hook)
+ (add-hook 'post-command-hook #'semantic-complete-post-command-hook)
;; Go!
(semantic-complete-inline-force-display)
)
inserted into the current context.")
(cl-defmethod semantic-collector-calculate-completions-raw
- ((obj semantic-collector-analyze-completions) prefix completionlist)
- "calculate the completions for prefix from completionlist."
+ ((obj semantic-collector-analyze-completions) prefix _completionlist)
+ "calculate the completions for prefix from COMPLETIONLIST."
;; if there are no completions yet, calculate them.
(if (not (slot-boundp obj 'first-pass-completions))
(oset obj first-pass-completions
prefix
(oref obj first-pass-completions)))))
-(cl-defmethod semantic-collector-cleanup ((obj semantic-collector-abstract))
+(cl-defmethod semantic-collector-cleanup ((_obj semantic-collector-abstract))
"Clean up any mess this collector may have."
nil)
(list (cons table result)))))
(cl-defmethod semantic-collector-calculate-completions
- ((obj semantic-collector-abstract) prefix partial)
+ ((obj semantic-collector-abstract) prefix _partial)
"Calculate completions for prefix as setup for other queries."
(let* ((case-fold-search semantic-case-fold)
(same-prefix-p (semantic-collector-last-prefix= obj prefix))
(cond ((or same-prefix-p
(and last-prefix (eq (compare-strings
last-prefix 0 nil
- prefix 0 (length last-prefix)) t)))
+ prefix 0 (length last-prefix))
+ t)))
;; We have the same prefix, or last-prefix is a
;; substring of the of new prefix, in which case we are
;; refining our symbol so just re-use cache.
(> (length prefix) 1)
(eq (compare-strings
prefix 0 nil
- last-prefix 0 (length prefix)) t))
+ last-prefix 0 (length prefix))
+ t))
;; The new prefix is a substring of the old
;; prefix, and it's longer than one character.
;; Perform a full search to pull in additional
(semanticdb-find-result-nth-in-buffer (oref obj current-exact-match) 0)))
(cl-defmethod semantic-collector-all-completions
- ((obj semantic-collector-abstract) prefix)
+ ((obj semantic-collector-abstract) _prefix)
"For OBJ, retrieve all completions matching PREFIX.
The returned list consists of all the tags currently
matching PREFIX."
(oref obj last-all-completions)))
(cl-defmethod semantic-collector-try-completion
- ((obj semantic-collector-abstract) prefix)
+ ((obj semantic-collector-abstract) _prefix)
"For OBJ, attempt to match PREFIX.
See `try-completion' for details on how this works.
Return nil for no match.
(oref obj last-completion)))
(cl-defmethod semantic-collector-calculate-cache
- ((obj semantic-collector-abstract))
+ ((_obj semantic-collector-abstract))
"Calculate the completion cache for OBJ."
nil
)
:abstract t)
(cl-defmethod make-instance ((this (subclass semantic-collector-buffer-abstract))
- &rest args)
+ &rest _args)
"Reuse previously created objects of this type in buffer."
(let ((old nil)
(bl semantic-collector-per-buffer-list))
old))
;; Buffer specific collectors should flush themselves
-(defun semantic-collector-buffer-flush (newcache)
+(defun semantic-collector-buffer-flush (_newcache)
"Flush all buffer collector objects.
NEWCACHE is the new tag table, but we ignore it."
(condition-case nil
(error nil)))
(add-hook 'semantic-after-toplevel-cache-change-hook
- 'semantic-collector-buffer-flush)
+ #'semantic-collector-buffer-flush)
;;; DEEP BUFFER SPECIFIC COMPLETION
;;
(cl-defmethod semantic-collector-calculate-completions-raw
- ((obj semantic-collector-project) prefix completionlist)
- "Calculate the completions for prefix from completionlist."
+ ((obj semantic-collector-project) prefix _completionlist)
+ "Calculate the completions for prefix from COMPLETIONLIST."
(semanticdb-find-tags-for-completion prefix (oref obj path)))
;;; Brutish Project search
"semantic/db-find")
(cl-defmethod semantic-collector-calculate-completions-raw
- ((obj semantic-collector-project-brutish) prefix completionlist)
- "Calculate the completions for prefix from completionlist."
+ ((obj semantic-collector-project-brutish) prefix _completionlist)
+ "Calculate the completions for prefix from COMPLETIONLIST."
(require 'semantic/db-find)
(semanticdb-brute-deep-find-tags-for-completion prefix (oref obj path)))
"Completion engine for tags in a project.")
(cl-defmethod semantic-collector-calculate-completions-raw
- ((obj semantic-collector-local-members) prefix completionlist)
- "Calculate the completions for prefix from completionlist."
+ ((obj semantic-collector-local-members) prefix _completionlist)
+ "Calculate the completions for prefix from COMPLETIONLIST."
(let* ((scope (or (oref obj scope)
(oset obj scope (semantic-calculate-scope))))
(localstuff (oref scope scope)))
(define-obsolete-function-alias 'semantic-displayor-cleanup
#'semantic-displayer-cleanup "27.1")
-(cl-defmethod semantic-displayer-cleanup ((obj semantic-displayer-abstract))
+(cl-defmethod semantic-displayer-cleanup ((_obj semantic-displayer-abstract))
"Clean up any mess this displayer may have."
nil)
(define-obsolete-function-alias 'semantic-displayor-show-request
#'semantic-displayer-show-request "27.1")
-(cl-defmethod semantic-displayer-show-request ((obj semantic-displayer-abstract))
+(cl-defmethod semantic-displayer-show-request ((_obj semantic-displayer-abstract))
"A request to show the current tags table."
(ding))
(define-obsolete-function-alias 'semantic-displayor-focus-request
#'semantic-displayer-focus-request "27.1")
-(cl-defmethod semantic-displayer-focus-request ((obj semantic-displayer-abstract))
+(cl-defmethod semantic-displayer-focus-request ((_obj semantic-displayer-abstract))
"A request to for the displayer to focus on some tag option."
(ding))
(define-obsolete-function-alias 'semantic-displayor-scroll-request
#'semantic-displayer-scroll-request "27.1")
-(cl-defmethod semantic-displayer-scroll-request ((obj semantic-displayer-abstract))
+(cl-defmethod semantic-displayer-scroll-request ((_obj semantic-displayer-abstract))
"A request to for the displayer to scroll the completion list (if needed)."
(scroll-other-window))
(define-obsolete-function-alias 'semantic-displayor-focus-previous
#'semantic-displayer-focus-previous "27.1")
-(cl-defmethod semantic-displayer-focus-previous ((obj semantic-displayer-abstract))
+(cl-defmethod semantic-displayer-focus-previous ((_obj semantic-displayer-abstract))
"Set the current focus to the previous item."
nil)
(define-obsolete-function-alias 'semantic-displayor-focus-next
#'semantic-displayer-focus-next "27.1")
-(cl-defmethod semantic-displayer-focus-next ((obj semantic-displayer-abstract))
+(cl-defmethod semantic-displayer-focus-next ((_obj semantic-displayer-abstract))
"Set the current focus to the next item."
nil)
(define-obsolete-function-alias 'semantic-displayor-current-focus
#'semantic-displayer-current-focus "27.1")
-(cl-defmethod semantic-displayer-current-focus ((obj semantic-displayer-abstract))
+(cl-defmethod semantic-displayer-current-focus ((_obj semantic-displayer-abstract))
"Return a single tag currently in focus.
This object type doesn't do focus, so will never have a focus object."
nil)
(define-obsolete-function-alias 'semantic-displayor-set-completions
#'semantic-displayer-set-completions "27.1")
(cl-defmethod semantic-displayer-set-completions ((obj semantic-displayer-focus-abstract)
- table prefix)
+ _table _prefix)
"Set the list of tags to be completed over to TABLE."
(cl-call-next-method)
(slot-makeunbound obj 'focus))
"Display completions options in a tooltip.
Display mechanism using tooltip for a list of possible completions.")
-(cl-defmethod initialize-instance :after ((obj semantic-displayer-tooltip) &rest args)
+(cl-defmethod initialize-instance :after ((_obj semantic-displayer-tooltip) &rest _args)
"Make sure we have tooltips required."
(require 'tooltip))
(table (semantic-unique-tag-table-by-name tablelong))
(completions (mapcar semantic-completion-displayer-format-tag-function table))
(numcompl (length completions))
- (typing-count (oref obj typing-count))
+ ;; (typing-count (oref obj typing-count))
(mode (oref obj mode))
(max-tags (oref obj max-tags-initial))
(matchtxt (semantic-completion-text))
msg msg-tail)
;; Keep a count of the consecutive completion commands entered by the user.
- (if (and (stringp (this-command-keys))
- (string= (this-command-keys) "\C-i"))
- (oset obj typing-count (1+ (oref obj typing-count)))
- (oset obj typing-count 0))
+ (oset obj typing-count
+ (if (equal (this-command-keys) "\C-i")
+ (1+ (oref obj typing-count))
+ 0))
(cond
((eq mode 'quiet)
;; Switch back to standard mode if user presses key more than 5 times.
(when semantic-idle-scheduler-verbose-flag
(setq msg "[NO MATCH]"))))
;; Create the tooltip text.
- (setq msg (concat msg (mapconcat 'identity completions "\n"))))
+ (setq msg (concat msg (mapconcat #'identity completions "\n"))))
;; Add any tail info.
(setq msg (concat msg msg-tail))
;; Display tooltip.
(define-obsolete-function-alias 'semantic-displayor-set-completions
#'semantic-displayer-set-completions "27.1")
(cl-defmethod semantic-displayer-set-completions ((obj semantic-displayer-ghost)
- table prefix)
+ _table _prefix)
"Set the list of tags to be completed over to TABLE."
(cl-call-next-method)
-
- (semantic-displayer-cleanup obj)
- )
+ (semantic-displayer-cleanup obj))
(define-obsolete-function-alias 'semantic-displayor-show-request
(semantic-displayer-traditional-with-focus-highlight)
(with-current-buffer (oref context buffer)
(goto-char (cdr (oref context bounds)))
- (concat prompt (mapconcat 'identity syms ".")
- (if syms "." "")
- ))
+ (concat prompt (mapconcat #'identity syms ".")
+ (if syms "." "")))
nil
inp
history)))
-;;; semantic/db-debug.el --- Extra level debugging routines for Semantic
+;;; semantic/db-debug.el --- Extra level debugging routines for Semantic -*- lexical-binding: t; -*-
-;;; Copyright (C) 2008-2021 Free Software Foundation, Inc.
+;; Copyright (C) 2008-2021 Free Software Foundation, Inc.
;; Author: Eric M. Ludlam <zappo@gnu.org>
(data-debug-new-buffer "*SEMANTICDB*")
(data-debug-insert-stuff-list db "*")))
-(defalias 'semanticdb-adebug-database-list 'semanticdb-dump-all-table-summary)
+(defalias 'semanticdb-adebug-database-list #'semanticdb-dump-all-table-summary)
(defun semanticdb-adebug-current-database ()
"Run ADEBUG on the current database."
-;;; semantic/db-ebrowse.el --- Semanticdb backend using ebrowse.
+;;; semantic/db-ebrowse.el --- Semanticdb backend using ebrowse. -*- lexical-binding: t; -*-
;; Copyright (C) 2005-2021 Free Software Foundation, Inc.
(let* ((savein (semanticdb-ebrowse-file-for-directory dir))
(filebuff (get-buffer-create "*SEMANTICDB EBROWSE TMP*"))
(files (directory-files (expand-file-name dir) t))
- (mma auto-mode-alist)
- (regexp nil)
+ ;; (mma auto-mode-alist)
+ ;; (regexp nil)
)
;; Create the input to the ebrowse command
(with-current-buffer filebuff
()
"Search Ebrowse for symbols.")
-(cl-defmethod semanticdb-needs-refresh-p ((table semanticdb-table-ebrowse))
+(cl-defmethod semanticdb-needs-refresh-p ((_table semanticdb-table-ebrowse))
"EBROWSE database do not need to be refreshed.
JAVE: stub for needs-refresh, because, how do we know if BROWSE files
(insert-file-contents B)
(let ((ans nil)
(efcn (symbol-function 'ebrowse-show-progress)))
- (fset 'ebrowse-show-progress #'(lambda (&rest junk) nil))
+ (fset 'ebrowse-show-progress #'(lambda (&rest _junk) nil))
(unwind-protect ;; Protect against errors w/ ebrowse
(setq ans (list B (ebrowse-read)))
;; These items must always happen
(while T
(let* ((tree (car T))
- (class (ebrowse-ts-class tree)); root class of tree
+ ;;(class (ebrowse-ts-class tree)); root class of tree
;; Something funny going on with this file thing...
- (filename (or (ebrowse-cs-source-file class)
- (ebrowse-cs-file class)))
+ ;; (filename (or (ebrowse-cs-source-file class)
+ ;; (ebrowse-cs-file class)))
)
(cond
((ebrowse-globals-tree-p tree)
;;; Filename based methods
;;
-(defun semanticdb-ebrowse-add-globals-to-table (dbe tree)
+(defun semanticdb-ebrowse-add-globals-to-table (_dbe tree)
"For database DBE, add the ebrowse TREE into the table."
(if (or (not (ebrowse-ts-p tree))
(not (ebrowse-globals-tree-p tree)))
(signal 'wrong-type-argument (list 'ebrowse-ts-p tree)))
(let* ((class (ebrowse-ts-class tree))
- (fname (or (ebrowse-cs-source-file class)
- (ebrowse-cs-file class)
- ;; Not def'd here, assume our current
- ;; file
- (concat default-directory "/unknown-proxy.hh")))
+ ;; (fname (or (ebrowse-cs-source-file class)
+ ;; (ebrowse-cs-file class)
+ ;; ;; Not def'd here, assume our current
+ ;; ;; file
+ ;; (concat default-directory "/unknown-proxy.hh")))
(vars (ebrowse-ts-member-functions tree))
(fns (ebrowse-ts-member-variables tree))
(toks nil)
;; how your new search routines are implemented.
;;
(cl-defmethod semanticdb-find-tags-by-name-method
- ((table semanticdb-table-ebrowse) name &optional tags)
+ ((_table semanticdb-table-ebrowse) _name &optional tags)
"Find all tags named NAME in TABLE.
Return a list of tags."
;;(message "semanticdb-find-tags-by-name-method name -- %s" name)
)
(cl-defmethod semanticdb-find-tags-by-name-regexp-method
- ((table semanticdb-table-ebrowse) regex &optional tags)
+ ((_table semanticdb-table-ebrowse) _regex &optional tags)
"Find all tags with name matching REGEX in TABLE.
Optional argument TAGS is a list of tags to search.
Return a list of tags."
))
(cl-defmethod semanticdb-find-tags-for-completion-method
- ((table semanticdb-table-ebrowse) prefix &optional tags)
+ ((_table semanticdb-table-ebrowse) _prefix &optional tags)
"In TABLE, find all occurrences of tags matching PREFIX.
Optional argument TAGS is a list of tags to search.
Returns a table of all matching tags."
))
(cl-defmethod semanticdb-find-tags-by-class-method
- ((table semanticdb-table-ebrowse) class &optional tags)
+ ((_table semanticdb-table-ebrowse) _class &optional tags)
"In TABLE, find all occurrences of tags of CLASS.
Optional argument TAGS is a list of tags to search.
Returns a table of all matching tags."
;;
(cl-defmethod semanticdb-deep-find-tags-by-name-method
- ((table semanticdb-table-ebrowse) name &optional tags)
+ ((_table semanticdb-table-ebrowse) _name &optional _tags)
"Find all tags name NAME in TABLE.
Optional argument TAGS is a list of tags to search.
Like `semanticdb-find-tags-by-name-method' for ebrowse."
(cl-call-next-method))
(cl-defmethod semanticdb-deep-find-tags-by-name-regexp-method
- ((table semanticdb-table-ebrowse) regex &optional tags)
+ ((_table semanticdb-table-ebrowse) _regex &optional _tags)
"Find all tags with name matching REGEX in TABLE.
Optional argument TAGS is a list of tags to search.
Like `semanticdb-find-tags-by-name-method' for ebrowse."
(cl-call-next-method))
(cl-defmethod semanticdb-deep-find-tags-for-completion-method
- ((table semanticdb-table-ebrowse) prefix &optional tags)
+ ((_table semanticdb-table-ebrowse) _prefix &optional _tags)
"In TABLE, find all occurrences of tags matching PREFIX.
Optional argument TAGS is a list of tags to search.
Like `semanticdb-find-tags-for-completion-method' for ebrowse."
;;; Advanced Searches
;;
(cl-defmethod semanticdb-find-tags-external-children-of-type-method
- ((table semanticdb-table-ebrowse) type &optional tags)
+ ((_table semanticdb-table-ebrowse) _type &optional tags)
"Find all nonterminals which are child elements of TYPE
Optional argument TAGS is a list of tags to search.
Return a list of tags."
-;;; semantic/db-el.el --- Semantic database extensions for Emacs Lisp
+;;; semantic/db-el.el --- Semantic database extensions for Emacs Lisp -*- lexical-binding: t; -*-
-;;; Copyright (C) 2002-2021 Free Software Foundation, Inc.
+;; Copyright (C) 2002-2021 Free Software Foundation, Inc.
;; Author: Eric M. Ludlam <zappo@gnu.org>
;; Keywords: tags
"Return nil, we never need a refresh."
nil)
-(cl-defmethod semanticdb-debug-info ((obj semanticdb-table-emacs-lisp))
+(cl-defmethod semanticdb-debug-info ((_obj semanticdb-table-emacs-lisp))
(list "(proxy)"))
(cl-defmethod cl-print-object ((obj semanticdb-table-emacs-lisp) stream)
-;;; semantic/db-file.el --- Save a semanticdb to a cache file.
+;;; semantic/db-file.el --- Save a semanticdb to a cache file. -*- lexical-binding: t; -*-
-;;; Copyright (C) 2000-2005, 2007-2021 Free Software Foundation, Inc.
+;; Copyright (C) 2000-2021 Free Software Foundation, Inc.
;; Author: Eric M. Ludlam <zappo@gnu.org>
;; Keywords: tags
(object-assoc (file-name-nondirectory filename) 'file (oref obj tables)))
(cl-defmethod semanticdb-file-name-non-directory
- ((dbclass (subclass semanticdb-project-database-file)))
+ ((_dbclass (subclass semanticdb-project-database-file)))
"Return the file name DBCLASS will use.
File name excludes any directory part."
semanticdb-default-file-name)
(cl-defmethod semanticdb-file-name-directory
- ((dbclass (subclass semanticdb-project-database-file)) directory)
+ ((_dbclass (subclass semanticdb-project-database-file)) directory)
"Return the relative directory to where DBCLASS will save its cache file.
The returned path is related to DIRECTORY."
(if semanticdb-default-save-directory
-;;; semantic/db-find.el --- Searching through semantic databases.
+;;; semantic/db-find.el --- Searching through semantic databases. -*- lexical-binding: t; -*-
;; Copyright (C) 2000-2021 Free Software Foundation, Inc.
)
(cl-defmethod semanticdb-synchronize ((idx semanticdb-find-search-index)
- new-tags)
+ _new-tags)
"Synchronize the search index IDX with some NEW-TAGS."
;; Reset our parts.
(semantic-reset idx)
;; Notify dependants by clearing their indices.
(semanticdb-notify-references
(oref idx table)
- (lambda (tab me)
+ (lambda (tab _me)
(semantic-reset (semanticdb-get-table-index tab))))
)
;; Notify dependants by clearing their indices.
(semanticdb-notify-references
(oref idx table)
- (lambda (tab me)
+ (lambda (tab _me)
(semantic-reset (semanticdb-get-table-index tab))))
)
;; Else, not an include, by just a type.
;; Notify dependants by clearing their indices.
(semanticdb-notify-references
(oref idx table)
- (lambda (tab me)
+ (lambda (tab _me)
(let ((tab-idx (semanticdb-get-table-index tab)))
;; Not a full reset?
(when (oref tab-idx type-cache)
(file (semantic-tag-file-name tag))
(str1 (format "%S %s" mode name))
(str2 (format " : %s" file))
- (tip nil))
+ ;; (tip nil)
+ )
(insert prefix prebuttontext str1)
(setq end (point))
(insert str2)
(put-text-property start end 'ddebug (cdr consdata))
(put-text-property start end 'ddebug-indent(length prefix))
(put-text-property start end 'ddebug-prefix prefix)
- (put-text-property start end 'help-echo tip)
+ ;; (put-text-property start end 'help-echo tip)
(put-text-property start end 'ddebug-function
'data-debug-insert-tag-parts-from-point)
(insert "\n")
(when norm
;; The normalized tags can now be found based on that
;; tags table.
- (condition-case foo
+ (condition-case nil
(progn
(semanticdb-set-buffer (car norm))
;; Now reset ans
-;;; semantic/db-global.el --- Semantic database extensions for GLOBAL
+;;; semantic/db-global.el --- Semantic database extensions for GLOBAL -*- lexical-binding: t; -*-
;; Copyright (C) 2002-2006, 2008-2021 Free Software Foundation, Inc.
(let ((semanticdb--ih (mode-local-value mode 'semantic-init-mode-hook)))
(eval `(setq-mode-local
,mode semantic-init-mode-hook
- (cons 'semanticdb-enable-gnu-global-hook semanticdb--ih))))
+ (cons 'semanticdb-enable-gnu-global-hook ',semanticdb--ih))
+ t))
t
)
)
)
"A table for returning search results from GNU Global.")
-(cl-defmethod semanticdb-debug-info ((obj semanticdb-table-global))
+(cl-defmethod semanticdb-debug-info ((_obj semanticdb-table-global))
(list "(proxy)"))
(cl-defmethod cl-print-object ((obj semanticdb-table-global) stream)
(princ (eieio-object-name obj (semanticdb-debug-info obj))
stream))
-(cl-defmethod semanticdb-equivalent-mode ((table semanticdb-table-global) &optional buffer)
+(cl-defmethod semanticdb-equivalent-mode ((_table semanticdb-table-global) &optional _buffer)
"Return t, pretend that this table's mode is equivalent to BUFFER.
Equivalent modes are specified by the `semantic-equivalent-major-modes'
local variable."
(cl-call-next-method))
-(cl-defmethod semanticdb-file-table ((obj semanticdb-project-database-global) filename)
+(cl-defmethod semanticdb-file-table ((obj semanticdb-project-database-global) _filename)
"From OBJ, return FILENAME's associated table object."
;; We pass in "don't load". I wonder if we need to avoid that or not?
(car (semanticdb-get-database-tables obj))
;; Only NAME based searches work with GLOBAL as that is all it tracks.
;;
(cl-defmethod semanticdb-find-tags-by-name-method
- ((table semanticdb-table-global) name &optional tags)
+ ((_table semanticdb-table-global) name &optional tags)
"Find all tags named NAME in TABLE.
Return a list of tags."
(if tags
)))
(cl-defmethod semanticdb-find-tags-by-name-regexp-method
- ((table semanticdb-table-global) regex &optional tags)
+ ((_table semanticdb-table-global) regex &optional tags)
"Find all tags with name matching REGEX in TABLE.
Optional argument TAGS is a list of tags to search.
Return a list of tags."
)))
(cl-defmethod semanticdb-find-tags-for-completion-method
- ((table semanticdb-table-global) prefix &optional tags)
+ ((_table semanticdb-table-global) prefix &optional tags)
"In TABLE, find all occurrences of tags matching PREFIX.
Optional argument TAGS is a list of tags to search.
Returns a table of all matching tags."
-;;; semantic/db-javascript.el --- Semantic database extensions for javascript
+;;; semantic/db-javascript.el --- Semantic database extensions for javascript -*- lexical-binding: t; -*-
;; Copyright (C) 2002-2021 Free Software Foundation, Inc.
(cl-call-next-method)
)
-(cl-defmethod semanticdb-file-table ((obj semanticdb-project-database-javascript) filename)
+(cl-defmethod semanticdb-file-table ((obj semanticdb-project-database-javascript) _filename)
"From OBJ, return FILENAME's associated table object."
;; NOTE: See not for `semanticdb-get-database-tables'.
(car (semanticdb-get-database-tables obj))
)
-(cl-defmethod semanticdb-get-tags ((table semanticdb-table-javascript ))
+(cl-defmethod semanticdb-get-tags ((_table semanticdb-table-javascript ))
"Return the list of tags belonging to TABLE."
;; NOTE: Omniscient databases probably don't want to keep large tables
;; lolly-gagging about. Keep internal Emacs tables empty and
;; refer to alternate databases when you need something.
semanticdb-javascript-tags)
-(cl-defmethod semanticdb-equivalent-mode ((table semanticdb-table-javascript) &optional buffer)
+(cl-defmethod semanticdb-equivalent-mode ((_table semanticdb-table-javascript) &optional buffer)
"Return non-nil if TABLE's mode is equivalent to BUFFER.
Equivalent modes are specified by the `semantic-equivalent-major-modes'
local variable."
result))
(cl-defmethod semanticdb-find-tags-by-name-method
- ((table semanticdb-table-javascript) name &optional tags)
+ ((_table semanticdb-table-javascript) name &optional tags)
"Find all tags named NAME in TABLE.
Return a list of tags."
(if tags
))
(cl-defmethod semanticdb-find-tags-by-name-regexp-method
- ((table semanticdb-table-javascript) regex &optional tags)
+ ((_table semanticdb-table-javascript) regex &optional tags)
"Find all tags with name matching REGEX in TABLE.
Optional argument TAGS is a list of tags to search.
Return a list of tags."
))
(cl-defmethod semanticdb-find-tags-for-completion-method
- ((table semanticdb-table-javascript) prefix &optional tags)
+ ((_table semanticdb-table-javascript) prefix &optional tags)
"In TABLE, find all occurrences of tags matching PREFIX.
Optional argument TAGS is a list of tags to search.
Returns a table of all matching tags."
))
(cl-defmethod semanticdb-find-tags-by-class-method
- ((table semanticdb-table-javascript) class &optional tags)
+ ((_table semanticdb-table-javascript) _class &optional tags)
"In TABLE, find all occurrences of tags of CLASS.
Optional argument TAGS is a list of tags to search.
Returns a table of all matching tags."
;;; Advanced Searches
;;
(cl-defmethod semanticdb-find-tags-external-children-of-type-method
- ((table semanticdb-table-javascript) type &optional tags)
+ ((_table semanticdb-table-javascript) _type &optional tags)
"Find all nonterminals which are child elements of TYPE.
Optional argument TAGS is a list of tags to search.
Return a list of tags."
-;;; semantic/db-mode.el --- Semanticdb Minor Mode
+;;; semantic/db-mode.el --- Semanticdb Minor Mode -*- lexical-binding: t; -*-
;; Copyright (C) 2008-2021 Free Software Foundation, Inc.
-;;; semantic/db-ref.el --- Handle cross-db file references
+;;; semantic/db-ref.el --- Handle cross-db file references -*- lexical-binding: t; -*-
-;;; Copyright (C) 2007-2021 Free Software Foundation, Inc.
+;; Copyright (C) 2007-2021 Free Software Foundation, Inc.
;; Author: Eric M. Ludlam <zappo@gnu.org>
(object-add-to-list refdbt 'db-refs dbt)
t)))
-(cl-defmethod semanticdb-check-references ((dbt semanticdb-abstract-table))
+(cl-defmethod semanticdb-check-references ((_dbt semanticdb-abstract-table))
"Check and cleanup references in the database DBT.
Abstract tables would be difficult to reference."
;; Not sure how an abstract table can have references.
))
(setq refs (cdr refs)))))
-(cl-defmethod semanticdb-refresh-references ((dbt semanticdb-abstract-table))
+(cl-defmethod semanticdb-refresh-references ((_dbt semanticdb-abstract-table))
"Refresh references to DBT in other files."
;; alternate tables can't be edited, so can't be changed.
nil
-;;; semantic/db-typecache.el --- Manage Datatypes
+;;; semantic/db-typecache.el --- Manage Datatypes -*- lexical-binding: t; -*-
;; Copyright (C) 2007-2021 Free Software Foundation, Inc.
(oset tc stream nil)
- (mapc 'semantic-reset (oref tc dependants))
+ (mapc #'semantic-reset (oref tc dependants))
(oset tc dependants nil)
)
(cl-defmethod semanticdb-typecache-notify-reset ((tc semanticdb-typecache))
"Do a reset from a notify from a table we depend on."
(oset tc includestream nil)
- (mapc 'semantic-reset (oref tc dependants))
+ (mapc #'semantic-reset (oref tc dependants))
(oset tc dependants nil)
)
"Reset the typecache based on a partial reparse."
(when (semantic-find-tags-by-class 'include new-tags)
(oset tc includestream nil)
- (mapc 'semantic-reset (oref tc dependants))
+ (mapc #'semantic-reset (oref tc dependants))
(oset tc dependants nil)
)
(oset tc stream nil)
)
-(cl-defmethod semanticdb-synchronize ((cache semanticdb-database-typecache)
- new-tags)
+(cl-defmethod semanticdb-synchronize ((_cache semanticdb-database-typecache)
+ _new-tags)
"Synchronize a CACHE with some NEW-TAGS."
- )
+ nil)
-(cl-defmethod semanticdb-partial-synchronize ((cache semanticdb-database-typecache)
- new-tags)
+(cl-defmethod semanticdb-partial-synchronize ((_cache semanticdb-database-typecache)
+ _new-tags)
"Synchronize a CACHE with some changed NEW-TAGS."
- )
+ nil)
(cl-defmethod semanticdb-get-typecache ((db semanticdb-project-database))
"Retrieve the typecache from the semantic database DB.
namespaces instead."
tag)
-(cl-defmethod semanticdb-typecache-file-tags ((table semanticdb-abstract-table))
+(cl-defmethod semanticdb-typecache-file-tags ((_table semanticdb-abstract-table))
"No tags available from non-file based tables."
nil)
(oref cache filestream)
))
-(cl-defmethod semanticdb-typecache-include-tags ((table semanticdb-abstract-table))
+(cl-defmethod semanticdb-typecache-include-tags ((_table semanticdb-abstract-table))
"No tags available from non-file based tables."
nil)
(require 'data-debug)
(let* ((tab semanticdb-current-table)
(idx (semanticdb-get-table-index tab))
- (junk (oset idx type-cache nil)) ;; flush!
+ (_ (oset idx type-cache nil)) ;; flush!
(start (current-time))
(tc (semanticdb-typecache-for-database (oref tab parent-db)))
(end (current-time))
-;;; semantic/debug.el --- Language Debugger framework
+;;; semantic/debug.el --- Language Debugger framework -*- lexical-binding: t; -*-
;; Copyright (C) 2003-2005, 2008-2021 Free Software Foundation, Inc.
)
"One frame representation.")
-(cl-defmethod semantic-debug-frame-highlight ((frame semantic-debug-frame))
+(cl-defmethod semantic-debug-frame-highlight ((_frame semantic-debug-frame))
"Highlight one parser frame."
)
-(cl-defmethod semantic-debug-frame-info ((frame semantic-debug-frame))
+(cl-defmethod semantic-debug-frame-info ((_frame semantic-debug-frame))
"Display info about this one parser frame."
)
;;
(defvar semantic-debug-mode-map
(let ((km (make-sparse-keymap)))
- (define-key km "n" 'semantic-debug-next)
- (define-key km " " 'semantic-debug-next)
- (define-key km "s" 'semantic-debug-step)
- (define-key km "u" 'semantic-debug-up)
- (define-key km "d" 'semantic-debug-down)
- (define-key km "f" 'semantic-debug-fail-match)
- (define-key km "h" 'semantic-debug-print-state)
- (define-key km "s" 'semantic-debug-jump-to-source)
- (define-key km "p" 'semantic-debug-jump-to-parser)
- (define-key km "q" 'semantic-debug-quit)
- (define-key km "a" 'semantic-debug-abort)
- (define-key km "g" 'semantic-debug-go)
- (define-key km "b" 'semantic-debug-set-breakpoint)
+ (define-key km "n" #'semantic-debug-next)
+ (define-key km " " #'semantic-debug-next)
+ (define-key km "s" #'semantic-debug-step)
+ (define-key km "u" #'semantic-debug-up)
+ (define-key km "d" #'semantic-debug-down)
+ (define-key km "f" #'semantic-debug-fail-match)
+ (define-key km "h" #'semantic-debug-print-state)
+ (define-key km "s" #'semantic-debug-jump-to-source)
+ (define-key km "p" #'semantic-debug-jump-to-parser)
+ (define-key km "q" #'semantic-debug-quit)
+ (define-key km "a" #'semantic-debug-abort)
+ (define-key km "g" #'semantic-debug-go)
+ (define-key km "b" #'semantic-debug-set-breakpoint)
;; Some boring bindings.
- (define-key km "e" 'eval-expression)
+ (define-key km "e" #'eval-expression)
km)
"Keymap used when in semantic-debug-node.")
down to your parser later."
:abstract t)
-(cl-defmethod semantic-debug-parser-next ((parser semantic-debug-parser))
+(cl-defmethod semantic-debug-parser-next ((_parser semantic-debug-parser))
"Execute next for this PARSER."
(setq semantic-debug-user-command 'next)
)
-(cl-defmethod semantic-debug-parser-step ((parser semantic-debug-parser))
+(cl-defmethod semantic-debug-parser-step ((_parser semantic-debug-parser))
"Execute a step for this PARSER."
(setq semantic-debug-user-command 'step)
)
-(cl-defmethod semantic-debug-parser-go ((parser semantic-debug-parser))
+(cl-defmethod semantic-debug-parser-go ((_parser semantic-debug-parser))
"Continue execution in this PARSER until the next breakpoint."
(setq semantic-debug-user-command 'go)
)
-(cl-defmethod semantic-debug-parser-fail ((parser semantic-debug-parser))
+(cl-defmethod semantic-debug-parser-fail ((_parser semantic-debug-parser))
"Continue execution in this PARSER until the next breakpoint."
(setq semantic-debug-user-command 'fail)
)
-(cl-defmethod semantic-debug-parser-quit ((parser semantic-debug-parser))
+(cl-defmethod semantic-debug-parser-quit ((_parser semantic-debug-parser))
"Continue execution in this PARSER until the next breakpoint."
(setq semantic-debug-user-command 'quit)
)
-(cl-defmethod semantic-debug-parser-abort ((parser semantic-debug-parser))
+(cl-defmethod semantic-debug-parser-abort ((_parser semantic-debug-parser))
"Continue execution in this PARSER until the next breakpoint."
(setq semantic-debug-user-command 'abort)
)
-(cl-defmethod semantic-debug-parser-print-state ((parser semantic-debug-parser))
+(cl-defmethod semantic-debug-parser-print-state ((_parser semantic-debug-parser))
"Print state for this PARSER at the current breakpoint."
(with-slots (current-frame) semantic-debug-current-interface
(when current-frame
(semantic-debug-frame-info current-frame)
)))
-(cl-defmethod semantic-debug-parser-break ((parser semantic-debug-parser))
+(cl-defmethod semantic-debug-parser-break ((_parser semantic-debug-parser))
"Set a breakpoint for this PARSER."
)
;; Stack stuff
-(cl-defmethod semantic-debug-parser-frames ((parser semantic-debug-parser))
+(cl-defmethod semantic-debug-parser-frames ((_parser semantic-debug-parser))
"Return a list of frames for the current parser.
A frame is of the form:
( .. .what ? .. )
-;;; semantic/decorate.el --- Utilities for decorating/highlighting tokens.
+;;; semantic/decorate.el --- Utilities for decorating/highlighting tokens. -*- lexical-binding: t; -*-
-;;; Copyright (C) 1999-2003, 2005-2007, 2009-2021 Free Software
-;;; Foundation, Inc.
+;; Copyright (C) 1999-2021 Free Software Foundation, Inc.
;; Author: Eric M. Ludlam <zappo@gnu.org>
;; Keywords: syntax
))
;;; Momentary Highlighting - One line
-(defun semantic-momentary-highlight-one-tag-line (tag &optional face)
+(defun semantic-momentary-highlight-one-tag-line (tag &optional _face)
"Highlight the first line of TAG, unhighlighting before next command.
Optional argument FACE specifies the face to do the highlighting."
(save-excursion
(overlay-get (semantic-tag-overlay tag) 'invisible))
(defun semantic-overlay-signal-read-only
- (overlay after start end &optional len)
+ (overlay after start end &optional _len)
"Hook used in modification hooks to prevent modification.
Allows deletion of the entire text.
Argument OVERLAY, AFTER, START, END, and LEN are passed in by the system."
(declare-function semantic-current-tag "semantic/find")
-(defun semantic-set-tag-folded-isearch (overlay)
+(defun semantic-set-tag-folded-isearch (_overlay)
"Called by isearch if it discovers text in the folded region.
OVERLAY is passed in by isearch."
(semantic-set-tag-folded (semantic-current-tag) nil)
(defvar semantic-decoration-on-include-map
(let ((km (make-sparse-keymap)))
- (define-key km semantic-decoration-mouse-3 'semantic-decoration-include-menu)
+ (define-key km semantic-decoration-mouse-3 #'semantic-decoration-include-menu)
km)
"Keymap used on includes.")
(defvar semantic-decoration-on-unknown-include-map
(let ((km (make-sparse-keymap)))
;(define-key km [ mouse-2 ] 'semantic-decoration-unknown-include-describe)
- (define-key km semantic-decoration-mouse-3 'semantic-decoration-unknown-include-menu)
+ (define-key km semantic-decoration-mouse-3 #'semantic-decoration-unknown-include-menu)
km)
"Keymap used on unparsed includes.")
(defvar semantic-decoration-on-fileless-include-map
(let ((km (make-sparse-keymap)))
;(define-key km [ mouse-2 ] 'semantic-decoration-fileless-include-describe)
- (define-key km semantic-decoration-mouse-3 'semantic-decoration-fileless-include-menu)
+ (define-key km semantic-decoration-mouse-3 #'semantic-decoration-fileless-include-menu)
km)
"Keymap used on unparsed includes.")
(defvar semantic-decoration-on-unparsed-include-map
(let ((km (make-sparse-keymap)))
- (define-key km semantic-decoration-mouse-3 'semantic-decoration-unparsed-include-menu)
+ (define-key km semantic-decoration-mouse-3 #'semantic-decoration-unparsed-include-menu)
km)
"Keymap used on unparsed includes.")
(buffer-name)))
;; Add hooks
(add-hook 'semantic-after-partial-cache-change-hook
- 'semantic-decorate-tags-after-partial-reparse nil t)
+ #'semantic-decorate-tags-after-partial-reparse nil t)
(add-hook 'semantic-after-toplevel-cache-change-hook
- 'semantic-decorate-tags-after-full-reparse nil t)
+ #'semantic-decorate-tags-after-full-reparse nil t)
;; Add decorations to available tags. The above hooks ensure
;; that new tags will be decorated when they become available.
;; However, don't do this immediately, because EDE will be
(semantic-decorate-flush-decorations)
;; Remove hooks
(remove-hook 'semantic-after-partial-cache-change-hook
- 'semantic-decorate-tags-after-partial-reparse t)
+ #'semantic-decorate-tags-after-partial-reparse t)
(remove-hook 'semantic-after-toplevel-cache-change-hook
- 'semantic-decorate-tags-after-full-reparse t)))
+ #'semantic-decorate-tags-after-full-reparse t)))
(semantic-add-minor-mode 'semantic-decoration-mode
"")
(defun semantic-decoration-build-style-menu (style)
"Build a menu item for controlling a specific decoration STYLE."
- (vector (car style)
- `(lambda () (interactive)
- (semantic-toggle-decoration-style
- ,(car style)))
- :style 'toggle
- :selected `(semantic-decoration-style-enabled-p ,(car style))
- ))
+ (let ((s (car style)))
+ (vector s
+ (lambda () (interactive) (semantic-toggle-decoration-style s))
+ :style 'toggle
+ :selected `(semantic-decoration-style-enabled-p ',s))))
(defun semantic-build-decoration-mode-menu (&rest _ignore)
"Create a menu listing all the known decorations for toggling.
-;;; semantic/dep.el --- Methods for tracking dependencies (include files)
+;;; semantic/dep.el --- Methods for tracking dependencies (include files) -*- lexical-binding: t; -*-
;; Copyright (C) 2006-2021 Free Software Foundation, Inc.
(if (not mode) (setq mode major-mode))
(let ((dirtmp (file-name-as-directory dir))
(value
- (mode-local-value mode 'semantic-dependency-system-include-path))
- )
- (add-to-list 'value dirtmp t)
+ (mode-local-value mode 'semantic-dependency-system-include-path)))
(eval `(setq-mode-local ,mode
- semantic-dependency-system-include-path value))
- ))
+ semantic-dependency-system-include-path
+ ',(if (member dirtmp value) value
+ (append value (list dirtmp))))
+ t)))
;;;###autoload
(defun semantic-remove-system-include (dir &optional mode)
(value
(mode-local-value mode 'semantic-dependency-system-include-path))
)
- (setq value (delete dirtmp value))
+ (setq value (remove dirtmp value))
(eval `(setq-mode-local ,mode semantic-dependency-system-include-path
- value))
- ))
+ ',value)
+ t)))
;;;###autoload
(defun semantic-reset-system-include (&optional mode)
Modifies a mode-local version of
`semantic-dependency-system-include-path'."
(interactive)
- (if (not mode) (setq mode major-mode))
- (eval `(setq-mode-local ,mode semantic-dependency-system-include-path
- nil))
- )
+ (eval `(setq-mode-local ,(or mode major-mode)
+ semantic-dependency-system-include-path
+ nil)
+ t))
;;;###autoload
(defun semantic-customize-system-include-path (&optional mode)
-;;; semantic/doc.el --- Routines for documentation strings
+;;; semantic/doc.el --- Routines for documentation strings -*- lexical-binding: t; -*-
;; Copyright (C) 1999-2003, 2005, 2008-2021 Free Software Foundation,
;; Inc.
))
(define-obsolete-function-alias
'semantic-documentation-comment-preceeding-tag
- 'semantic-documentation-comment-preceding-tag
+ #'semantic-documentation-comment-preceding-tag
"25.1")
(defun semantic-doc-snarf-comment-for-tag (nosnarf)
-;;; semantic/ede-grammar.el --- EDE support for Semantic Grammar Files
+;;; semantic/ede-grammar.el --- EDE support for Semantic Grammar Files -*- lexical-binding: t; -*-
;; Copyright (C) 2003-2004, 2007-2021 Free Software Foundation, Inc.
(require 'ede/pconf)
(require 'ede/proj-elisp)
(require 'semantic/grammar)
+(eval-when-compile (require 'cl-lib))
;;; Code:
(defclass semantic-ede-proj-target-grammar (ede-proj-target-elisp)
"Compile Emacs Lisp programs.")
;;; Target options.
-(cl-defmethod ede-buffer-mine ((this semantic-ede-proj-target-grammar) buffer)
+(cl-defmethod ede-buffer-mine ((_this semantic-ede-proj-target-grammar) buffer)
"Return t if object THIS lays claim to the file in BUFFER.
Lays claim to all -by.el, and -wy.el files."
;; We need to be a little more careful than this, but at the moment it
(cl-defmethod project-compile-target ((obj semantic-ede-proj-target-grammar))
"Compile all sources in a Lisp target OBJ."
- (let* ((cb (current-buffer))
+ (let* (;; (cb (current-buffer))
(proj (ede-target-parent obj))
(default-directory (oref proj directory))
(comp 0)
(fname (progn (string-match ".*/\\(.+\\.el\\)" package)
(match-string 1 package)))
(src (ede-expand-filename obj fname))
- (csrc (concat (file-name-sans-extension src) ".elc")))
- (with-no-warnings
- (if (eq (byte-recompile-file src nil 0) t)
- (setq comp (1+ comp))
- (setq utd (1+ utd)))))))
+ ;; (csrc (concat (file-name-sans-extension src) ".elc"))
+ )
+ (cl-incf (if (eq (byte-recompile-file src nil 0) t)
+ comp utd)))))
(oref obj source))
(message "All Semantic Grammar sources are up to date in %s" (eieio-object-name obj))
(cons comp utd)))
-;;; semantic/edit.el --- Edit Management for Semantic
+;;; semantic/edit.el --- Edit Management for Semantic -*- lexical-binding: t; -*-
;; Copyright (C) 1999-2021 Free Software Foundation, Inc.
(sort ret #'(lambda (a b) (< (overlay-start a)
(overlay-start b)))))))
-(defun semantic-edits-change-function-handle-changes (start end length)
+(defun semantic-edits-change-function-handle-changes (start end _length)
"Run whenever a buffer controlled by `semantic-mode' change.
Tracks when and how the buffer is re-parsed.
Argument START, END, and LENGTH specify the bounds of the change."
start end)))
(parent nil)
(overlapped-tags nil)
- inner-start inner-end
+ inner-end ;; inner-start
(list-to-search nil))
;; By the time this is already called, we know that it is
;; not a leaf change, nor a between tag change. That leaves
(progn
;; We encompass one whole change.
(setq overlapped-tags (list (car tags))
- inner-start (semantic-tag-start (car tags))
+ ;; inner-start (semantic-tag-start (car tags))
inner-end (semantic-tag-end (car tags))
tags (cdr tags))
;; Keep looping while tags are inside the change.
;; This is a parent. Drop the children found
;; so far.
(setq overlapped-tags (list (car tags))
- inner-start (semantic-tag-start (car tags))
+ ;; inner-start (semantic-tag-start (car tags))
inner-end (semantic-tag-end (car tags))
)
;; It is not a parent encompassing tag
(setq overlapped-tags (cons (car tags)
overlapped-tags)
- inner-start (semantic-tag-start (car tags))))
+ ;; inner-start (semantic-tag-start (car tags))
+ ))
(setq tags (cdr tags)))
(if (not tags)
;; There are no tags left, and all tags originally
;query this when debugging to find
;source of bugs.
)
+ (ignore last-cond) ;; Don't warn about the var not being used.
(or changes
;; If we were called, and there are no changes, then we
;; don't know what to do. Force a full reparse.
-;;; semantic/find.el --- Search routines for Semantic
+;;; semantic/find.el --- Search routines for Semantic -*- lexical-binding: t; -*-
;; Copyright (C) 1999-2005, 2008-2021 Free Software Foundation, Inc.
)
(defun semantic-brute-find-tag-by-function
- (function streamorbuffer &optional search-parts search-includes)
+ (function streamorbuffer &optional search-parts _search-includes)
"Find all tags for which FUNCTION's value is non-nil within STREAMORBUFFER.
FUNCTION must return non-nil if an element of STREAM will be included
in the new list.
nl))
(defun semantic-brute-find-first-tag-by-function
- (function streamorbuffer &optional search-parts search-includes)
+ (function streamorbuffer &optional _search-parts _search-includes)
"Find the first tag which FUNCTION match within STREAMORBUFFER.
FUNCTION must return non-nil if an element of STREAM will be included
in the new list.
-;;; semantic/format.el --- Routines for formatting tags
+;;; semantic/format.el --- Routines for formatting tags -*- lexical-binding: t; -*-
;; Copyright (C) 1999-2005, 2007-2021 Free Software Foundation, Inc.
(car args) nil color 'variable))
out)
(setq args (cdr args)))
- (mapconcat 'identity (nreverse out) semantic-function-argument-separator)
+ (mapconcat #'identity (nreverse out) semantic-function-argument-separator)
))
;;; Data Type
;;; Abstract formatting functions
;;
-(defun semantic-format-tag-prin1 (tag &optional parent color)
+(defun semantic-format-tag-prin1 (tag &optional _parent _color)
"Convert TAG to a string that is the print name for TAG.
PARENT and COLOR are ignored."
(format "%S" tag))
Optional argument PARENT is the parent type if TAG is a detail.
Optional argument COLOR means highlight the prototype with font-lock colors.")
-(defun semantic-format-tag-name-default (tag &optional parent color)
+(defun semantic-format-tag-name-default (tag &optional _parent color)
"Return an abbreviated string describing TAG.
Optional argument PARENT is the parent type if TAG is a detail.
Optional argument COLOR means highlight the prototype with font-lock colors."
args
(if (eq class 'type) "}" ")"))))
(when mods
- (setq mods (concat (mapconcat 'identity mods " ") " ")))
+ (setq mods (concat (mapconcat #'identity mods " ") " ")))
(concat (or mods "")
(if type (concat type " "))
name
-;;; semantic/fw.el --- Framework for Semantic
+;;; semantic/fw.el --- Framework for Semantic -*- lexical-binding: t; -*-
-;;; Copyright (C) 1999-2021 Free Software Foundation, Inc.
+;; Copyright (C) 1999-2021 Free Software Foundation, Inc.
;; Author: Eric M. Ludlam <zappo@gnu.org>
;;; Compatibility
;;
-(define-obsolete-function-alias 'semantic-overlay-live-p 'overlay-buffer "27.1")
-(define-obsolete-function-alias 'semantic-make-overlay 'make-overlay "27.1")
-(define-obsolete-function-alias 'semantic-overlay-put 'overlay-put "27.1")
-(define-obsolete-function-alias 'semantic-overlay-get 'overlay-get "27.1")
+(define-obsolete-function-alias 'semantic-overlay-live-p #'overlay-buffer "27.1")
+(define-obsolete-function-alias 'semantic-make-overlay #'make-overlay "27.1")
+(define-obsolete-function-alias 'semantic-overlay-put #'overlay-put "27.1")
+(define-obsolete-function-alias 'semantic-overlay-get #'overlay-get "27.1")
(define-obsolete-function-alias 'semantic-overlay-properties
- 'overlay-properties "27.1")
-(define-obsolete-function-alias 'semantic-overlay-move 'move-overlay "27.1")
-(define-obsolete-function-alias 'semantic-overlay-delete 'delete-overlay "27.1")
-(define-obsolete-function-alias 'semantic-overlays-at 'overlays-at "27.1")
-(define-obsolete-function-alias 'semantic-overlays-in 'overlays-in "27.1")
-(define-obsolete-function-alias 'semantic-overlay-buffer 'overlay-buffer "27.1")
-(define-obsolete-function-alias 'semantic-overlay-start 'overlay-start "27.1")
-(define-obsolete-function-alias 'semantic-overlay-end 'overlay-end "27.1")
+ #'overlay-properties "27.1")
+(define-obsolete-function-alias 'semantic-overlay-move #'move-overlay "27.1")
+(define-obsolete-function-alias 'semantic-overlay-delete #'delete-overlay "27.1")
+(define-obsolete-function-alias 'semantic-overlays-at #'overlays-at "27.1")
+(define-obsolete-function-alias 'semantic-overlays-in #'overlays-in "27.1")
+(define-obsolete-function-alias 'semantic-overlay-buffer #'overlay-buffer "27.1")
+(define-obsolete-function-alias 'semantic-overlay-start #'overlay-start "27.1")
+(define-obsolete-function-alias 'semantic-overlay-end #'overlay-end "27.1")
(define-obsolete-function-alias 'semantic-overlay-next-change
- 'next-overlay-change "27.1")
+ #'next-overlay-change "27.1")
(define-obsolete-function-alias 'semantic-overlay-previous-change
- 'previous-overlay-change "27.1")
-(define-obsolete-function-alias 'semantic-overlay-lists 'overlay-lists "27.1")
-(define-obsolete-function-alias 'semantic-overlay-p 'overlayp "27.1")
-(define-obsolete-function-alias 'semantic-read-event 'read-event "27.1")
-(define-obsolete-function-alias 'semantic-popup-menu 'popup-menu "27.1")
+ #'previous-overlay-change "27.1")
+(define-obsolete-function-alias 'semantic-overlay-lists #'overlay-lists "27.1")
+(define-obsolete-function-alias 'semantic-overlay-p #'overlayp "27.1")
+(define-obsolete-function-alias 'semantic-read-event #'read-event "27.1")
+(define-obsolete-function-alias 'semantic-popup-menu #'popup-menu "27.1")
(define-obsolete-function-alias 'semantic-buffer-local-value
- 'buffer-local-value "27.1")
+ #'buffer-local-value "27.1")
(defun semantic-event-window (event)
"Extract the window from EVENT."
;; Since Emacs 22 major mode functions should use `run-mode-hooks' to
;; run major mode hooks.
-(define-obsolete-function-alias 'semantic-run-mode-hooks 'run-mode-hooks "28.1")
+(define-obsolete-function-alias 'semantic-run-mode-hooks #'run-mode-hooks "28.1")
;; Fancy compat usage now handled in cedet-compat
(define-obsolete-function-alias 'semantic-subst-char-in-string
- 'subst-char-in-string "28.1")
+ #'subst-char-in-string "28.1")
(defun semantic-delete-overlay-maybe (overlay)
"Delete OVERLAY if it is a semantic token overlay."
(setq semantic-cache-data-overlays
(cons o semantic-cache-data-overlays))
;;(message "Adding to cache: %s" o)
- (add-hook 'post-command-hook 'semantic-cache-data-post-command-hook)
+ (add-hook 'post-command-hook #'semantic-cache-data-post-command-hook)
))
(defun semantic-cache-data-post-command-hook ()
;; Remove ourselves if we have removed all overlays.
(unless semantic-cache-data-overlays
(remove-hook 'post-command-hook
- 'semantic-cache-data-post-command-hook)))
+ #'semantic-cache-data-post-command-hook)))
(defun semantic-get-cache-data (name &optional point)
"Get cached data with NAME from optional POINT."
`current-buffer' is a selected Semantic enabled buffer."
(mode-local-map-file-buffers function #'semantic-active-p))
-(defalias 'semantic-map-mode-buffers 'mode-local-map-mode-buffers)
+(defalias 'semantic-map-mode-buffers #'mode-local-map-mode-buffers)
(defun semantic-install-function-overrides (overrides &optional transient)
"Install the function OVERRIDES in the specified environment.
\f
;;; Special versions of Find File
;;
+(defvar recentf-exclude)
+(defvar semantic-init-hook)
+(defvar ede-auto-add-method)
+(defvar flymake-start-syntax-check-on-find-file)
+(defvar auto-insert)
+
(defun semantic-find-file-noselect (file &optional nowarn rawfile wildcards)
"Call `find-file-noselect' with various features turned off.
Use this when referencing a file that will be soon deleted.
-;;; semantic/html.el --- Semantic details for html files
+;;; semantic/html.el --- Semantic details for html files -*- lexical-binding: t; -*-
;; Copyright (C) 2004-2005, 2007-2021 Free Software Foundation, Inc.
"Alist of sectioning commands and their relative level.")
(define-mode-local-override semantic-parse-region
- html-mode (&rest ignore)
+ html-mode (&rest _ignore)
"Parse the current html buffer for semantic tags.
IGNORE any arguments. Always parse the whole buffer.
Each tag returned is of the form:
(\"NAME\" section (:members CHILDREN))
or
(\"NAME\" anchor)"
- (mapcar 'semantic-html-expand-tag
+ (mapcar #'semantic-html-expand-tag
(semantic-html-parse-headings)))
(define-mode-local-override semantic-parse-changes
(let ((chil (semantic-html-components tag)))
(if chil
(semantic-tag-put-attribute
- tag :members (mapcar 'semantic-html-expand-tag chil)))
+ tag :members (mapcar #'semantic-html-expand-tag chil)))
(car (semantic--tag-expand tag))))
(defun semantic-html-components (tag)
;; This will use our parser.
(setq semantic-parser-name "HTML"
semantic--parse-table t
- imenu-create-index-function 'semantic-create-imenu-index
+ imenu-create-index-function #'semantic-create-imenu-index
semantic-command-separation-character ">"
semantic-type-relation-separator-character '(":")
semantic-symbol->name-assoc-list '((section . "Section")
-;;; semantic/ia-sb.el --- Speedbar analysis display interactor
+;;; semantic/ia-sb.el --- Speedbar analysis display interactor -*- lexical-binding: t; -*-
-;;; Copyright (C) 2002-2004, 2006, 2008-2021 Free Software Foundation,
-;;; Inc.
+;; Copyright (C) 2002-2021 Free Software Foundation, Inc.
;; Author: Eric M. Ludlam <zappo@gnu.org>
;; Keywords: syntax
(require 'speedbar)
;;; Code:
-(defvar semantic-ia-sb-key-map nil
+(defvar semantic-ia-sb-key-map
+ (let ((map (speedbar-make-specialized-keymap)))
+ ;; Basic features.
+ (define-key map "\C-m" #'speedbar-edit-line)
+ (define-key map "I" #'semantic-ia-sb-show-tag-info)
+ map)
"Keymap used when in semantic analysis display mode.")
-(if semantic-ia-sb-key-map
- nil
- (setq semantic-ia-sb-key-map (speedbar-make-specialized-keymap))
-
- ;; Basic features.
- (define-key semantic-ia-sb-key-map "\C-m" 'speedbar-edit-line)
- (define-key semantic-ia-sb-key-map "I" 'semantic-ia-sb-show-tag-info)
- )
-
(defvar semantic-ia-sb-easymenu-definition
'( "---"
; [ "Expand" speedbar-expand-line nil ]
(speedbar-change-initial-expansion-list "Analyze")
)
-(defun semantic-ia-speedbar (directory zero)
+(defun semantic-ia-speedbar (_directory _zero)
"Create buttons in speedbar which define the current analysis at POINT.
DIRECTORY is the current directory, which is ignored, and ZERO is 0."
(let ((analysis nil)
;; An index for the argument the prefix is in:
(let ((arg (oref context argument))
(args (semantic-tag-function-arguments (car func)))
- (idx 0)
+ ;; (idx 0)
)
(speedbar-insert-separator
(format "Argument #%d" (oref context index)))
(setq tok (get-text-property (point) 'speedbar-token)))
(semantic-ia-sb-tag-info nil tok 0)))
-(defun semantic-ia-sb-tag-info (text tag indent)
+(defun semantic-ia-sb-tag-info (_text tag _indent)
"Display as much information as we can about tag.
Show the information in a shrunk split-buffer and expand
out as many details as possible.
(get-buffer-window "*Tag Information*")))
(select-frame speedbar-frame))))
-(defun semantic-ia-sb-line-path (&optional depth)
+(defun semantic-ia-sb-line-path (&optional _depth)
"Return the file name associated with DEPTH."
(save-match-data
(let* ((tok (speedbar-line-token))
- (buff (if (semantic-tag-buffer tok)
- (semantic-tag-buffer tok)
- (current-buffer))))
+ (buff (or (semantic-tag-buffer tok)
+ (current-buffer))))
(buffer-file-name buff))))
-(defun semantic-ia-sb-complete (text tag indent)
+(defun semantic-ia-sb-complete (_text tag _indent)
"At point in the attached buffer, complete the symbol clicked on.
TEXT TAG and INDENT are the details."
;; Find the specified bounds from the current analysis.
-;;; semantic/ia.el --- Interactive Analysis functions
+;;; semantic/ia.el --- Interactive Analysis functions -*- lexical-binding: t; -*-
-;;; Copyright (C) 2000-2021 Free Software Foundation, Inc.
+;; Copyright (C) 2000-2021 Free Software Foundation, Inc.
;; Author: Eric M. Ludlam <zappo@gnu.org>
;; Keywords: syntax
(insert "("))
(t nil))))
-(defalias 'semantic-ia-get-completions 'semantic-ia-get-completions-deprecated)
+(defalias 'semantic-ia-get-completions #'semantic-ia-get-completions-deprecated)
(make-obsolete 'semantic-ia-get-completions
#'semantic-analyze-possible-completions "28.1")
-(defun semantic-ia-get-completions-deprecated (context point)
+(defun semantic-ia-get-completions-deprecated (context _point)
"A function to help transition away from `semantic-ia-get-completions'.
Return completions based on CONTEXT at POINT."
(declare (obsolete semantic-analyze-possible-completions "28.1"))
(popup-menu semantic-idle-breadcrumbs-popup-menu)
(select-window old-window)))
-(defmacro semantic-idle-breadcrumbs--tag-function (function)
+(defun semantic-idle-breadcrumbs--tag-function (function)
"Return lambda expression calling FUNCTION when called from a popup."
- `(lambda (event)
- (interactive "e")
- (let* ((old-window (selected-window))
- (window (semantic-event-window event))
- (column (car (nth 6 (nth 1 event)))) ;; TODO semantic-event-column?
- (tag (progn
- (select-window window t)
- (plist-get
- (text-properties-at column header-line-format)
- 'tag))))
- (,function tag)
- (select-window old-window)))
- )
+ (lambda (event)
+ (interactive "e")
+ (let* ((old-window (selected-window))
+ (window (semantic-event-window event))
+ (column (car (nth 6 (nth 1 event)))) ;; TODO semantic-event-column?
+ (tag (progn
+ (select-window window t)
+ (plist-get
+ (text-properties-at column header-line-format)
+ 'tag))))
+ (funcall function tag)
+ (select-window old-window))))
;; TODO does this work for mode-line case?
(defvar semantic-idle-breadcrumbs-popup-map
;; mouse-1 goes to clicked tag
(define-key map
[ header-line mouse-1 ]
- (semantic-idle-breadcrumbs--tag-function
- semantic-go-to-tag))
+ (semantic-idle-breadcrumbs--tag-function #'semantic-go-to-tag))
;; mouse-3 pops up a context menu
(define-key map
[ header-line mouse-3 ]
"Breadcrumb Tag"
(vector
"Go to Tag"
- (semantic-idle-breadcrumbs--tag-function
- semantic-go-to-tag)
+ (semantic-idle-breadcrumbs--tag-function #'semantic-go-to-tag)
:active t
:help "Jump to this tag")
;; TODO these entries need minor changes (optional tag argument) in
;; (semantic-menu-item
;; (vector
;; "Copy Tag"
- ;; (semantic-idle-breadcrumbs--tag-function
- ;; senator-copy-tag)
+ ;; (semantic-idle-breadcrumbs--tag-function #'senator-copy-tag)
;; :active t
;; :help "Copy this tag"))
;; (semantic-menu-item
;; (vector
;; "Kill Tag"
- ;; (semantic-idle-breadcrumbs--tag-function
- ;; senator-kill-tag)
+ ;; (semantic-idle-breadcrumbs--tag-function #'senator-kill-tag)
;; :active t
;; :help "Kill tag text to the kill ring, and copy the tag to
;; the tag ring"))
;; (semantic-menu-item
;; (vector
;; "Copy Tag to Register"
- ;; (semantic-idle-breadcrumbs--tag-function
- ;; senator-copy-tag-to-register)
+ ;; (semantic-idle-breadcrumbs--tag-function #'senator-copy-tag-to-register)
;; :active t
;; :help "Copy this tag"))
;; (semantic-menu-item
;; (vector
;; "Narrow to Tag"
- ;; (semantic-idle-breadcrumbs--tag-function
- ;; senator-narrow-to-defun)
+ ;; (semantic-idle-breadcrumbs--tag-function #'senator-narrow-to-defun)
;; :active t
;; :help "Narrow to the bounds of the current tag"))
;; (semantic-menu-item
;; (vector
;; "Fold Tag"
- ;; (semantic-idle-breadcrumbs--tag-function
- ;; senator-fold-tag-toggle)
+ ;; (semantic-idle-breadcrumbs--tag-function #'senator-fold-tag-toggle)
;; :active t
;; :style 'toggle
;; :selected '(let ((tag (semantic-current-tag)))
-;;; semantic/imenu.el --- Use Semantic as an imenu tag generator
+;;; semantic/imenu.el --- Use Semantic as an imenu tag generator -*- lexical-binding: t; -*-
;; Copyright (C) 2000-2005, 2007-2008, 2010-2021 Free Software
;; Foundation, Inc.
(defcustom semantic-imenu-summary-function 'semantic-format-tag-abbreviate
"Function to use when creating items in Imenu.
Some useful functions are found in `semantic-format-tag-functions'."
- :group 'semantic-imenu
:type semantic-format-tag-custom-list)
(make-variable-buffer-local 'semantic-imenu-summary-function)
;;;###autoload
(defcustom semantic-imenu-bucketize-file t
"Non-nil if tags in a file are to be grouped into buckets."
- :group 'semantic-imenu
:type 'boolean)
(make-variable-buffer-local 'semantic-imenu-bucketize-file)
"Non-nil if types in a file should adopt externally defined members.
C++ and CLOS can define methods that are not in the body of a class
definition."
- :group 'semantic-imenu
:type 'boolean)
(defcustom semantic-imenu-buckets-to-submenu t
"Non-nil if buckets of tags are to be turned into submenus.
This option is ignored if `semantic-imenu-bucketize-file' is nil."
- :group 'semantic-imenu
:type 'boolean)
(make-variable-buffer-local 'semantic-imenu-buckets-to-submenu)
;;;###autoload
(defcustom semantic-imenu-expand-type-members t
"Non-nil if types should have submenus with members in them."
- :group 'semantic-imenu
:type 'boolean)
(make-variable-buffer-local 'semantic-imenu-expand-type-members)
"Non-nil if members of a type should be grouped into buckets.
A nil value means to keep them in the same order.
Overridden to nil if `semantic-imenu-bucketize-file' is nil."
- :group 'semantic-imenu
:type 'boolean)
(make-variable-buffer-local 'semantic-imenu-bucketize-type-members)
"Function to use when sorting tags in the buckets of functions.
See `semantic-bucketize' and the FILTER argument for more details
on this function."
- :group 'semantic-imenu
:type '(radio (const :tag "No Sorting" nil)
(const semantic-sort-tags-by-name-increasing)
(const semantic-sort-tags-by-name-decreasing)
Doesn't actually parse the entire directory, but displays tags for all files
currently listed in the current Semantic database.
This variable has no meaning if semanticdb is not active."
- :group 'semantic-imenu
:type 'boolean)
(defcustom semantic-imenu-auto-rebuild-directory-indexes nil
"If non-nil automatically rebuild directory index imenus.
That is when a directory index imenu is updated, automatically rebuild
other buffer local ones based on the same semanticdb."
- :group 'semantic-imenu
:type 'boolean)
(defvar semantic-imenu-directory-current-file nil
(setq imenu--index-alist nil)))))
))
-(defun semantic-imenu-flush-fcn (&optional ignore)
+(defun semantic-imenu-flush-fcn (&optional _ignore)
"This function is called as a hook to clear the imenu cache.
It is cleared after any parsing.
IGNORE arguments."
(setq imenu--index-alist nil
imenu-menubar-modified-tick 0))
(remove-hook 'semantic-after-toplevel-cache-change-hook
- 'semantic-imenu-flush-fcn t)
+ #'semantic-imenu-flush-fcn t)
(remove-hook 'semantic-after-partial-cache-change-hook
- 'semantic-imenu-flush-fcn t)
+ #'semantic-imenu-flush-fcn t)
)
;;;###autoload
"Create an imenu index for any buffer which supports Semantic.
Uses the output of the Semantic parser to create the index.
Optional argument STREAM is an optional stream of tags used to create menus."
- (setq imenu-default-goto-function 'semantic-imenu-goto-function)
+ (setq imenu-default-goto-function #'semantic-imenu-goto-function)
(prog1
(if (and semantic-imenu-index-directory
(featurep 'semantic/db)
(semantic-create-imenu-index-1
(or stream (semantic-fetch-tags-fast)) nil))
(add-hook 'semantic-after-toplevel-cache-change-hook
- 'semantic-imenu-flush-fcn nil t)
+ #'semantic-imenu-flush-fcn nil t)
(add-hook 'semantic-after-partial-cache-change-hook
- 'semantic-imenu-flush-fcn nil t)))
+ #'semantic-imenu-flush-fcn nil t)))
(defun semantic-create-imenu-directory-index (&optional stream)
"Create an imenu tag index based on all files active in semanticdb.
;; Clear imenu cache to redraw the imenu.
(semantic-imenu-flush-fcn))))
-(add-hook 'semanticdb-mode-hook 'semantic-imenu-semanticdb-hook)
+(add-hook 'semanticdb-mode-hook #'semantic-imenu-semanticdb-hook)
;;; Interactive Utilities
;;
(defcustom semantic-which-function-use-color nil
"Use color when displaying the current function with `which-function'."
- :group 'semantic-imenu
:type 'boolean)
(defun semantic-default-which-function (taglist)
-;;; semantic/java.el --- Semantic functions for Java
+;;; semantic/java.el --- Semantic functions for Java -*- lexical-binding: t; -*-
-;;; Copyright (C) 1999-2021 Free Software Foundation, Inc.
+;; Copyright (C) 1999-2021 Free Software Foundation, Inc.
;; Author: David Ponce <david@dponce.com>
(let* ((name (semantic-tag-name tag))
(rsplit (nreverse (split-string name "\\." t)))
(newclassname (car rsplit))
- (newpkg (mapconcat 'identity (reverse (cdr rsplit)) ".")))
+ (newpkg (mapconcat #'identity (reverse (cdr rsplit)) ".")))
(semantic-tag-set-name tag newclassname)
(setq xpand
(list tag
(define-mode-local-override semantic-ctxt-scoped-types
java-mode (&optional point)
"Return a list of type names currently in scope at POINT."
- (mapcar 'semantic-tag-name
+ (mapcar #'semantic-tag-name
(semantic-find-tags-by-class
'type (semantic-find-tag-by-overlay point))))
;; Prototype handler
;;
-(defun semantic-java-prototype-function (tag &optional parent color)
+(defun semantic-java-prototype-function (tag &optional _parent color)
"Return a function (method) prototype for TAG.
Optional argument PARENT is a parent (containing) item.
Optional argument COLOR indicates that color should be mixed in.
(or type "") (if type " " "")
name "(" argp ")")))
-(defun semantic-java-prototype-variable (tag &optional parent color)
+(defun semantic-java-prototype-variable (tag &optional _parent color)
"Return a variable (field) prototype for TAG.
Optional argument PARENT is a parent (containing) item.
Optional argument COLOR indicates that color should be mixed in.
(semantic--format-colorize-text name 'variable)
name))))
-(defun semantic-java-prototype-type (tag &optional parent color)
+(defun semantic-java-prototype-type (tag &optional _parent color)
"Return a type (class/interface) prototype for TAG.
Optional argument PARENT is a parent (containing) item.
Optional argument COLOR indicates that color should be mixed in.
(define-mode-local-override semantic-tag-include-filename java-mode (tag)
"Return a suitable path for (some) Java imports."
(let ((name (semantic-tag-name tag)))
- (concat (mapconcat 'identity (split-string name "\\.") "/") ".java")))
+ (concat (mapconcat #'identity (split-string name "\\.") "/") ".java")))
;; Documentation handler
;;
(or semantic-java-doc-with-name-tags
(setq semantic-java-doc-with-name-tags
(semantic-java-doc-keywords-map
- #'(lambda (k p)
- k)
+ #'(lambda (k _p) k)
'with-name)))
(or semantic-java-doc-with-ref-tags
(setq semantic-java-doc-with-ref-tags
(semantic-java-doc-keywords-map
- #'(lambda (k p)
- k)
+ #'(lambda (k _p) k)
'with-ref)))
(or semantic-java-doc-extra-type-tags
))
(define-obsolete-function-alias
'semantic-lex-spp-anlyzer-do-replace
- 'semantic-lex-spp-analyzer-do-replace "25.1")
+ #'semantic-lex-spp-analyzer-do-replace "25.1")
(defvar semantic-lex-spp-replacements-enabled t
"Non-nil means do replacements when finding keywords.
(semantic-lex-init)
(semantic-clear-toplevel-cache)
(remove-hook 'semantic-lex-reset-functions
- 'semantic-lex-spp-reset-hook t)
+ #'semantic-lex-spp-reset-hook t)
))
;; Second Cheat: copy key variables regarding macro state from the
;;; Lexical Analyzer framework settings
;;
-(defvar-local semantic-lex-analyzer 'semantic-lex
+(defvar-local semantic-lex-analyzer #'semantic-lex
"The lexical analyzer used for a given buffer.
See `semantic-lex' for documentation.")
-;;; semantic/mru-bookmark.el --- Automatic bookmark tracking
+;;; semantic/mru-bookmark.el --- Automatic bookmark tracking -*- lexical-binding: t; -*-
;; Copyright (C) 2007-2021 Free Software Foundation, Inc.
)
"A single bookmark.")
-(cl-defmethod initialize-instance :after ((sbm semantic-bookmark) &rest fields)
+(cl-defmethod initialize-instance :after ((sbm semantic-bookmark) &rest _fields)
"Initialize the bookmark SBM with details about :tag."
(condition-case nil
(save-excursion
(setq idx (1+ idx)))))
(add-hook 'semantic-before-toplevel-cache-flush-hook
- 'semantic-mrub-cache-flush-fcn)
+ #'semantic-mrub-cache-flush-fcn)
;;; EDIT tracker
;;
:group 'semantic-modes
:type 'boolean
:require 'semantic/util-modes
- :initialize 'custom-initialize-default
- :set (lambda (sym val)
+ :initialize #'custom-initialize-default
+ :set (lambda (_sym val)
(global-semantic-mru-bookmark-mode (if val 1 -1))))
;;;###autoload
(defvar semantic-mru-bookmark-mode-map
(let ((km (make-sparse-keymap)))
- (define-key km "\C-xB" 'semantic-mrub-switch-tags)
+ (define-key km "\C-xB" #'semantic-mrub-switch-tags)
km)
"Keymap for mru-bookmark minor mode.")
(error "Buffer %s was not set up for parsing"
(buffer-name)))
(add-hook 'semantic-edits-new-change-functions
- 'semantic-mru-bookmark-change-hook-fcn nil t)
+ #'semantic-mru-bookmark-change-hook-fcn nil t)
(add-hook 'semantic-edits-move-change-hooks
- 'semantic-mru-bookmark-change-hook-fcn nil t))
+ #'semantic-mru-bookmark-change-hook-fcn nil t))
;; Remove hooks
(remove-hook 'semantic-edits-new-change-functions
- 'semantic-mru-bookmark-change-hook-fcn t)
+ #'semantic-mru-bookmark-change-hook-fcn t)
(remove-hook 'semantic-edits-move-change-hooks
- 'semantic-mru-bookmark-change-hook-fcn t)))
+ #'semantic-mru-bookmark-change-hook-fcn t)))
(semantic-add-minor-mode 'semantic-mru-bookmark-mode
"k")
-;;; semantic/senator.el --- SEmantic NAvigaTOR
+;;; semantic/senator.el --- SEmantic NAvigaTOR -*- lexical-binding: t; -*-
;; Copyright (C) 2000-2021 Free Software Foundation, Inc.
As a special exception, if the value is nil, Senator's navigation
commands recognize all tag classes."
- :group 'senator
:type '(repeat (symbol)))
;;;###autoload
(make-variable-buffer-local 'senator-step-at-tag-classes)
If t, the navigation commands stop at the start and end of any
tag, where possible."
- :group 'senator
:type '(choice :tag "Identifiers"
(repeat :menu-tag "Symbols" (symbol))
(const :tag "All" t)))
(defcustom senator-highlight-found nil
"If non-nil, Senator commands momentarily highlight found tags."
- :group 'senator
:type 'boolean)
(make-variable-buffer-local 'senator-highlight-found)
'(code block)
"List of ignored tag classes.
Tags of those classes are excluded from search."
- :group 'senator
:type '(repeat (symbol :tag "class")))
(defun senator-search-default-tag-filter (tag)
((symbolp classes)
(list classes))
((stringp classes)
- (mapcar 'read (split-string classes)))
+ (mapcar #'read (split-string classes)))
(t
(signal 'wrong-type-argument (list classes)))
))
senator--search-filter t)
(kill-local-variable 'senator--search-filter)
(if classes
- (let ((tag (make-symbol "tag"))
- (names (mapconcat 'symbol-name classes "', `")))
+ (let ((names (mapconcat #'symbol-name classes "', `")))
(setq-local senator--search-filter
- `(lambda (,tag)
- (memq (semantic-tag-class ,tag) ',classes)))
+ (lambda (tag)
+ (memq (semantic-tag-class tag) classes)))
(add-hook 'senator-search-tag-filter-functions
senator--search-filter nil t)
(message "Limit search to `%s' tags" names))
"Non-nil if isearch does semantic search.
This is a buffer local variable.")
-(defun senator-beginning-of-defun (&optional arg)
+(defun senator-beginning-of-defun (&optional _arg)
"Move backward to the beginning of a defun.
Use semantic tags to navigate.
ARG is the number of tags to navigate (not yet implemented)."
(goto-char (semantic-tag-start tag)))
(beginning-of-line))))
-(defun senator-end-of-defun (&optional arg)
+(defun senator-end-of-defun (&optional _arg)
"Move forward to next end of defun.
Use semantic tags to navigate.
ARG is the number of tags to navigate (not yet implemented)."
(setq-local senator-old-isearch-search-fun
isearch-search-fun-function))
(setq-local isearch-search-fun-function
- 'senator-isearch-search-fun))
+ #'senator-isearch-search-fun))
;; When `senator-isearch-semantic-mode' is off restore the
;; previous `isearch-search-fun-function'.
(when (eq isearch-search-fun-function 'senator-isearch-search-fun)
-;;; semantic/sort.el --- Utilities for sorting and re-arranging tag tables.
+;;; semantic/sort.el --- Utilities for sorting and re-arranging tag tables. -*- lexical-binding: t; -*-
-;;; Copyright (C) 1999-2005, 2007-2021 Free Software Foundation, Inc.
+;; Copyright (C) 1999-2021 Free Software Foundation, Inc.
;; Author: Eric M. Ludlam <zappo@gnu.org>
;; Keywords: syntax
(semantic-flatten-tags-table components)
lists)))))
table)
- (apply 'append (nreverse lists))
- ))
+ (apply #'append (nreverse lists))))
\f
;;; Buckets:
(semantic-tag-name tag) tag)))
(if m (apply #'append (mapcar #'cdr m))))
(semantic--find-tags-by-function
- `(lambda (tok)
- ;; This bit of annoying backquote forces the contents of
- ;; tag into the generated lambda.
- (semantic-tag-external-member-p ',tag tok))
- (current-buffer))
- ))
+ (lambda (tok)
+ ;; This bit of annoying backquote forces the contents of
+ ;; tag into the generated lambda.
+ (semantic-tag-external-member-p tag tok))
+ (current-buffer))))
(define-overloadable-function semantic-tag-external-class (tag)
"Return a list of real tags that faux TAG might represent.
(:override)
)
+(defvar semanticdb-search-system-databases)
+
(defun semantic-tag-external-class-default (tag)
"Return a list of real tags that faux TAG might represent.
See `semantic-tag-external-class' for details."
-;;; semantic/symref.el --- Symbol Reference API
+;;; semantic/symref.el --- Symbol Reference API -*- lexical-binding: t; -*-
;; Copyright (C) 2008-2021 Free Software Foundation, Inc.
)
(when (not (class-p class))
(error "Unknown symref tool %s" semantic-symref-tool))
- (setq inst (apply 'make-instance class args))
+ (setq inst (apply #'make-instance class args))
inst))
(defvar semantic-symref-last-result nil
(kill-buffer buff)))
semantic-symref-recently-opened-buffers)
(setq semantic-symref-recently-opened-buffers nil)
- (remove-hook 'post-command-hook 'semantic-symref-cleanup-recent-buffers-fcn)
+ (remove-hook 'post-command-hook #'semantic-symref-cleanup-recent-buffers-fcn)
)
(cl-defmethod semantic-symref-result-get-tags ((result semantic-symref-result)
lines)))
;; Kill off dead buffers, unless we were requested to leave them open.
(if (not open-buffers)
- (add-hook 'post-command-hook 'semantic-symref-cleanup-recent-buffers-fcn)
+ (add-hook 'post-command-hook #'semantic-symref-cleanup-recent-buffers-fcn)
;; Else, just clear the saved buffers so they aren't deleted later.
(setq semantic-symref-recently-opened-buffers nil)
)
(defvar semantic-symref-results-mode-map
(let ((km (make-sparse-keymap)))
(suppress-keymap km)
- (define-key km "\C-i" 'forward-button)
- (define-key km "\M-C-i" 'backward-button)
- (define-key km " " 'push-button)
- (define-key km "-" 'semantic-symref-list-toggle-showing)
- (define-key km "=" 'semantic-symref-list-toggle-showing)
- (define-key km "+" 'semantic-symref-list-toggle-showing)
- (define-key km "n" 'semantic-symref-list-next-line)
- (define-key km "p" 'semantic-symref-list-prev-line)
- (define-key km "q" 'quit-window)
- (define-key km "\C-c\C-e" 'semantic-symref-list-expand-all)
- (define-key km "\C-c\C-r" 'semantic-symref-list-contract-all)
- (define-key km "R" 'semantic-symref-list-rename-open-hits)
- (define-key km "(" 'semantic-symref-list-create-macro-on-open-hit)
- (define-key km "E" 'semantic-symref-list-call-macro-on-open-hits)
+ (define-key km "\C-i" #'forward-button)
+ (define-key km "\M-C-i" #'backward-button)
+ (define-key km " " #'push-button)
+ (define-key km "-" #'semantic-symref-list-toggle-showing)
+ (define-key km "=" #'semantic-symref-list-toggle-showing)
+ (define-key km "+" #'semantic-symref-list-toggle-showing)
+ (define-key km "n" #'semantic-symref-list-next-line)
+ (define-key km "p" #'semantic-symref-list-prev-line)
+ (define-key km "q" #'quit-window)
+ (define-key km "\C-c\C-e" #'semantic-symref-list-expand-all)
+ (define-key km "\C-c\C-r" #'semantic-symref-list-contract-all)
+ (define-key km "R" #'semantic-symref-list-rename-open-hits)
+ (define-key km "(" #'semantic-symref-list-create-macro-on-open-hit)
+ (define-key km "E" #'semantic-symref-list-call-macro-on-open-hits)
km)
"Keymap used in `semantic-symref-results-mode'.")
-;;; semantic/tag-file.el --- Routines that find files based on tags.
+;;; semantic/tag-file.el --- Routines that find files based on tags. -*- lexical-binding: t; -*-
;; Copyright (C) 1999-2005, 2007-2021 Free Software Foundation, Inc.
-;;; semantic/tag-ls.el --- Language Specific override functions for tags
+;;; semantic/tag-ls.el --- Language Specific override functions for tags -*- lexical-binding: t; -*-
;; Copyright (C) 1999-2004, 2006-2021 Free Software Foundation, Inc.
`semantic--tag-attribute-similar-p-default' to do the default equality tests if
ATTR is not special for that mode.")
-(defun semantic--tag-attribute-similar-p-default (attr value1 value2 ignorable-attributes)
+(defun semantic--tag-attribute-similar-p-default (_attr value1 value2 ignorable-attributes)
"For ATTR, VALUE1, VALUE2 and IGNORABLE-ATTRIBUTES, test for similarity."
(cond
;; Tag sublists require special testing.
(when (not (eq (length taglist1) (length taglist2)))
(setq ans nil))
(while (and ans taglist1 taglist2)
- (setq ans (apply 'semantic-tag-similar-p
+ (setq ans (apply #'semantic-tag-similar-p
(car taglist1) (car taglist2)
ignorable-attributes)
taglist1 (cdr taglist1)
(or stream-or-buffer tag))))
(:override-with-args (tag stream))))
-(defun semantic-tag-full-package-default (tag stream)
+(defun semantic-tag-full-package-default (_tag stream)
"Default method for `semantic-tag-full-package' for TAG.
Return the name of the first tag of class `package' in STREAM."
(let ((pack (car-safe (semantic-find-tags-by-class 'package stream))))
(setq parent (semantic-tag-calculate-parent tag)))
(:override))
-(defun semantic-tag-protection-default (tag &optional parent)
+(defun semantic-tag-protection-default (tag &optional _parent)
"Return the protection of TAG as a child of PARENT default action.
See `semantic-tag-protection'."
(let ((mods (semantic-tag-modifiers tag))
(let ((s (car mods)))
(setq prot
;; A few silly defaults to get things started.
- (cond ((or (string= s "public")
- (string= s "extern")
- (string= s "export"))
+ (cond ((member s '("public" "extern" "export"))
'public)
((string= s "private")
'private)
The default behavior (if not overridden with `tag-abstract-p'
is to return true if `abstract' is in the type modifiers.")
-(defun semantic-tag-abstract-p-default (tag &optional parent)
+(defun semantic-tag-abstract-p-default (tag &optional _parent)
"Return non-nil if TAG is abstract as a child of PARENT default action.
See `semantic-tag-abstract-p'."
(let ((mods (semantic-tag-modifiers tag))
(abs nil))
(while (and (not abs) mods)
(if (stringp (car mods))
- (setq abs (or (string= (car mods) "abstract")
- (string= (car mods) "virtual"))))
+ (setq abs (member (car mods) '("abstract" "virtual"))))
(setq mods (cdr mods)))
abs))
The default behavior (if not overridden with `tag-leaf-p'
is to return true if `leaf' is in the type modifiers.")
-(defun semantic-tag-leaf-p-default (tag &optional parent)
+(defun semantic-tag-leaf-p-default (tag &optional _parent)
"Return non-nil if TAG is leaf as a child of PARENT default action.
See `semantic-tag-leaf-p'."
(let ((mods (semantic-tag-modifiers tag))
in the parent class, and are not instance specific.
UML notation specifies that STATIC entries are underlined.")
-(defun semantic-tag-static-p-default (tag &optional parent)
+(defun semantic-tag-static-p-default (tag &optional _parent)
"Return non-nil if TAG is static as a child of PARENT default action.
See `semantic-tag-static-p'."
(let ((mods (semantic-tag-modifiers tag))
-;;; semantic/tag-write.el --- Write tags to a text stream
+;;; semantic/tag-write.el --- Write tags to a text stream -*- lexical-binding: t; -*-
;; Copyright (C) 2008-2021 Free Software Foundation, Inc.
(if (semantic-tag-with-position-p tag)
(let ((bounds (semantic-tag-bounds tag)))
(princ " ")
- (prin1 (apply 'vector bounds))
+ (prin1 (apply #'vector bounds))
)
(princ " nil"))
;; End it.
Optional DEFAULT-VALUE is a string representing the default value of this
variable.
ATTRIBUTES is a list of additional attributes belonging to this tag."
- (apply 'semantic-tag name 'variable
+ (apply #'semantic-tag name 'variable
:type type
:default-value default-value
attributes))
ARG-LIST is a list of strings or semantic tags representing the
arguments of this function.
ATTRIBUTES is a list of additional attributes belonging to this tag."
- (apply 'semantic-tag name 'function
+ (apply #'semantic-tag name 'function
:type type
:arguments arg-list
attributes))
is a valid parent where there is no explicit parent, and only an
interface.
ATTRIBUTES is a list of additional attributes belonging to this tag."
- (apply 'semantic-tag name 'type
+ (apply #'semantic-tag name 'type
:type type
:members members
:superclasses (car parents)
SYSTEM-FLAG represents that we were able to identify this include as
belonging to the system, as opposed to belonging to the local project.
ATTRIBUTES is a list of additional attributes belonging to this tag."
- (apply 'semantic-tag name 'include
+ (apply #'semantic-tag name 'include
:system-flag system-flag
attributes))
DETAIL is extra information about this package, such as a location
where it can be found.
ATTRIBUTES is a list of additional attributes belonging to this tag."
- (apply 'semantic-tag name 'package
+ (apply #'semantic-tag name 'package
:detail detail
attributes))
NAME is a name for this code.
DETAIL is extra information about the code.
ATTRIBUTES is a list of additional attributes belonging to this tag."
- (apply 'semantic-tag name 'code
+ (apply #'semantic-tag name 'code
:detail detail
attributes))
It is safe for FILTER to modify the input tag and return it."
(when (not filter) (setq filter 'identity))
(when (not (semantic-tag-p tag))
- (signal 'wrong-type-argument (list tag 'semantic-tag-p)))
+ (signal 'wrong-type-argument (list tag #'semantic-tag-p)))
(let ((ol (semantic-tag-overlay tag))
(fn (semantic-tag-file-name tag)))
(funcall filter (list (semantic-tag-name tag)
META-TAG-CLASS is the class of the tag this tag is an alias.
VALUE is the aliased definition.
ATTRIBUTES is a list of additional attributes belonging to this tag."
- (apply 'semantic-tag name 'alias
+ (apply #'semantic-tag name 'alias
:aliasclass meta-tag-class
:definition value
attributes))
(condition-case err
;; If a hook bombs, ignore it! Usually this is tied into
;; some sort of critical system.
- (apply 'run-hook-with-args 'semantic--tag-hook-value arglist)
+ (apply #'run-hook-with-args 'semantic--tag-hook-value arglist)
(error (message "Error: %S" err)))))
\f
;;; Tags and Overlays
(defsubst semantic--tag-unlink-list-from-buffer (tags)
"Convert TAGS from using an overlay to using an overlay proxy.
This function is for internal use only."
- (mapcar 'semantic--tag-unlink-from-buffer tags))
+ (mapcar #'semantic--tag-unlink-from-buffer tags))
(defun semantic--tag-unlink-from-buffer (tag)
"Convert TAG from using an overlay to using an overlay proxy.
(defsubst semantic--tag-link-list-to-buffer (tags)
"Convert TAGS from using an overlay proxy to using an overlay.
This function is for internal use only."
- (mapc 'semantic--tag-link-to-buffer tags))
+ (mapc #'semantic--tag-link-to-buffer tags))
(defun semantic--tag-link-to-buffer (tag)
"Convert TAG from using an overlay proxy to using an overlay.
-;;; semantic/texi.el --- Semantic details for Texinfo files
+;;; semantic/texi.el --- Semantic details for Texinfo files -*- lexical-binding: t; -*-
;; Copyright (C) 2001-2005, 2007-2021 Free Software Foundation, Inc.
name of this section is.")
;;; Code:
-(defun semantic-texi-parse-region (&rest ignore)
+(defun semantic-texi-parse-region (&rest _ignore)
"Parse the current texinfo buffer for semantic tags.
IGNORE any arguments, always parse the whole buffer.
Each tag returned is of the form:
(let ((chil (semantic-tag-components tag)))
(if chil
(semantic-tag-put-attribute
- tag :members (mapcar 'semantic-texi-expand-tag chil)))
+ tag :members (mapcar #'semantic-texi-expand-tag chil)))
(car (semantic--tag-expand tag))))
(defun semantic-texi-parse-headings ()
nil))
(define-mode-local-override semantic-ctxt-current-class-list
- texinfo-mode (&optional point)
+ texinfo-mode (&optional _point)
"Determine the class of tags that can be used at POINT.
For texinfo, there two possibilities returned.
1) `function' - for a call to a texinfo function
(declare-function semantic-analyze-context "semantic/analyze")
(define-mode-local-override semantic-analyze-current-context
- texinfo-mode (point)
+ texinfo-mode (_point)
"Analysis context makes no sense for texinfo. Return nil."
(let* ((prefixandbounds (semantic-ctxt-current-symbol-and-bounds (point)))
(prefix (car prefixandbounds))
"List of commands that we might bother completing.")
(define-mode-local-override semantic-analyze-possible-completions
- texinfo-mode (context &rest flags)
+ texinfo-mode (context &rest _flags)
"List smart completions at point.
Since texinfo is not a programming language the default version is not
useful. Instead, look at the current symbol. If it is a command
(setq semantic-parser-name "TEXI"
;; Setup a dummy parser table to enable parsing!
semantic--parse-table t
- imenu-create-index-function 'semantic-create-imenu-index
+ imenu-create-index-function #'semantic-create-imenu-index
semantic-command-separation-character "@"
semantic-type-relation-separator-character '(":")
semantic-symbol->name-assoc-list '((section . "Section")
;; (local-set-key [(f9)] 'semantic-texi-update-doc-from-texi)
)
-(add-hook 'texinfo-mode-hook 'semantic-default-texi-setup)
+(add-hook 'texinfo-mode-hook #'semantic-default-texi-setup)
\f
;;; Special features of Texinfo tag streams
;; Turns out this might not be useful.
;; Delete later if that is true.
-(defun semantic-texi-find-documentation (name &optional type)
+(defun semantic-texi-find-documentation (name &optional _type)
"Find the function or variable NAME of TYPE in the texinfo source.
NAME is a string representing some functional symbol.
TYPE is a string, such as \"variable\" or \"Command\" used to find
-;;; semantic/util-modes.el --- Semantic minor modes
+;;; semantic/util-modes.el --- Semantic minor modes -*- lexical-binding: t; -*-
;; Copyright (C) 2000-2005, 2007-2021 Free Software Foundation, Inc.
:group 'semantic
:type 'boolean
:require 'semantic/util-modes
- :initialize 'custom-initialize-default
+ :initialize #'custom-initialize-default
:set (lambda (sym val)
(set-default sym val)
;; Update status of all Semantic enabled buffers
:group 'semantic
:type 'string
:require 'semantic/util-modes
- :initialize 'custom-initialize-default)
+ :initialize #'custom-initialize-default)
(defvar semantic-minor-modes-format nil
"Mode line format showing Semantic minor modes which are locally enabled.
(match-string 1 semantic-mode-line-prefix)
"S")))
(setq semantic-minor-modes-format
- `((:eval (if (or ,@(mapcar 'car locals))
+ `((:eval (if (or ,@(mapcar #'car locals))
,(concat " " prefix)))))
;; It would be easier to just put `locals' inside
;; semantic-minor-modes-format, but then things like
(cons elem minor-mode-alist)))))
(setcdr tail (nconc locals (cdr tail)))))))))
-(defun semantic-desktop-ignore-this-minor-mode (buffer)
+(defun semantic-desktop-ignore-this-minor-mode (_buffer)
"Installed as a minor-mode initializer for Desktop mode.
BUFFER is the buffer to not initialize a Semantic minor mode in."
nil)
(error "Buffer %s was not set up for parsing"
(buffer-name)))
(add-hook 'semantic-edits-new-change-functions
- 'semantic-highlight-edits-new-change-hook-fcn nil t))
+ #'semantic-highlight-edits-new-change-hook-fcn nil t))
;; Remove hooks
(remove-hook 'semantic-edits-new-change-functions
- 'semantic-highlight-edits-new-change-hook-fcn t)))
+ #'semantic-highlight-edits-new-change-hook-fcn t)))
(semantic-add-minor-mode 'semantic-highlight-edits-mode
"e")
(defvar semantic-show-unmatched-syntax-mode-map
(let ((km (make-sparse-keymap)))
- (define-key km "\C-c,`" 'semantic-show-unmatched-syntax-next)
+ (define-key km "\C-c,`" #'semantic-show-unmatched-syntax-next)
km)
"Keymap for command `semantic-show-unmatched-syntax-mode'.")
(buffer-name)))
;; Add hooks
(add-hook 'semantic-unmatched-syntax-hook
- 'semantic-show-unmatched-syntax nil t)
+ #'semantic-show-unmatched-syntax nil t)
(add-hook 'semantic-pre-clean-token-hooks
- 'semantic-clean-token-of-unmatched-syntax nil t)
+ #'semantic-clean-token-of-unmatched-syntax nil t)
;; Show unmatched syntax elements
(if (not (semantic--umatched-syntax-needs-refresh-p))
(semantic-show-unmatched-syntax
(semantic-unmatched-syntax-tokens))))
;; Remove hooks
(remove-hook 'semantic-unmatched-syntax-hook
- 'semantic-show-unmatched-syntax t)
+ #'semantic-show-unmatched-syntax t)
(remove-hook 'semantic-pre-clean-token-hooks
- 'semantic-clean-token-of-unmatched-syntax t)
+ #'semantic-clean-token-of-unmatched-syntax t)
;; Cleanup unmatched-syntax highlighting
(semantic-clean-unmatched-syntax-in-buffer)))
'(semantic-show-parser-state-string))))
;; Add hooks
(add-hook 'semantic-edits-new-change-functions
- 'semantic-show-parser-state-marker nil t)
+ #'semantic-show-parser-state-marker nil t)
(add-hook 'semantic-edits-incremental-reparse-failed-hook
- 'semantic-show-parser-state-marker nil t)
+ #'semantic-show-parser-state-marker nil t)
(add-hook 'semantic-after-partial-cache-change-hook
- 'semantic-show-parser-state-marker nil t)
+ #'semantic-show-parser-state-marker nil t)
(add-hook 'semantic-after-toplevel-cache-change-hook
- 'semantic-show-parser-state-marker nil t)
+ #'semantic-show-parser-state-marker nil t)
(semantic-show-parser-state-marker)
(add-hook 'semantic-before-auto-parse-hooks
- 'semantic-show-parser-state-auto-marker nil t)
+ #'semantic-show-parser-state-auto-marker nil t)
(add-hook 'semantic-after-auto-parse-hooks
- 'semantic-show-parser-state-marker nil t)
+ #'semantic-show-parser-state-marker nil t)
(add-hook 'semantic-before-idle-scheduler-reparse-hook
- 'semantic-show-parser-state-auto-marker nil t)
+ #'semantic-show-parser-state-auto-marker nil t)
(add-hook 'semantic-after-idle-scheduler-reparse-hook
- 'semantic-show-parser-state-marker nil t))
+ #'semantic-show-parser-state-marker nil t))
;; Remove parts of mode line
(setq mode-line-modified
(delq 'semantic-show-parser-state-string mode-line-modified))
;; Remove hooks
(remove-hook 'semantic-edits-new-change-functions
- 'semantic-show-parser-state-marker t)
+ #'semantic-show-parser-state-marker t)
(remove-hook 'semantic-edits-incremental-reparse-failed-hook
- 'semantic-show-parser-state-marker t)
+ #'semantic-show-parser-state-marker t)
(remove-hook 'semantic-after-partial-cache-change-hook
- 'semantic-show-parser-state-marker t)
+ #'semantic-show-parser-state-marker t)
(remove-hook 'semantic-after-toplevel-cache-change-hook
- 'semantic-show-parser-state-marker t)
+ #'semantic-show-parser-state-marker t)
(remove-hook 'semantic-before-auto-parse-hooks
- 'semantic-show-parser-state-auto-marker t)
+ #'semantic-show-parser-state-auto-marker t)
(remove-hook 'semantic-after-auto-parse-hooks
- 'semantic-show-parser-state-marker t)
+ #'semantic-show-parser-state-marker t)
(remove-hook 'semantic-before-idle-scheduler-reparse-hook
- 'semantic-show-parser-state-auto-marker t)
+ #'semantic-show-parser-state-auto-marker t)
(remove-hook 'semantic-after-idle-scheduler-reparse-hook
- 'semantic-show-parser-state-marker t)))
+ #'semantic-show-parser-state-marker t)))
(semantic-add-minor-mode 'semantic-show-parser-state-mode
"")
"String showing the parser state for this buffer.
See `semantic-show-parser-state-marker' for details.")
-(defun semantic-show-parser-state-marker (&rest ignore)
+(defun semantic-show-parser-state-marker (&rest _ignore)
"Set `semantic-show-parser-state-string' to indicate parser state.
This marker is one of the following:
`-' -> The cache is up to date.
(defvar semantic-stickyfunc-mode-map
(let ((km (make-sparse-keymap)))
- (define-key km [ header-line down-mouse-1 ] 'semantic-stickyfunc-menu)
+ (define-key km [ header-line down-mouse-1 ] #'semantic-stickyfunc-menu)
km)
"Keymap for stickyfunc minor mode.")
(defvar semantic-highlight-func-mode-map
(let ((km (make-sparse-keymap)))
- (define-key km [mouse-3] 'semantic-highlight-func-menu)
+ (define-key km [mouse-3] #'semantic-highlight-func-menu)
km)
"Keymap for highlight-func minor mode.")
(error "Buffer %s was not set up for parsing" (buffer-name)))
;; Setup our hook
(add-hook 'post-command-hook
- 'semantic-highlight-func-highlight-current-tag nil t))
+ #'semantic-highlight-func-highlight-current-tag nil t))
;; Disable highlight func mode
(remove-hook 'post-command-hook
- 'semantic-highlight-func-highlight-current-tag t)
+ #'semantic-highlight-func-highlight-current-tag t)
(semantic-highlight-func-highlight-current-tag t)))
(defun semantic-highlight-func-highlight-current-tag (&optional disable)
-;;; semantic/util.el --- Utilities for use with semantic tag tables
+;;; semantic/util.el --- Utilities for use with semantic tag tables -*- lexical-binding: t; -*-
-;;; Copyright (C) 1999-2005, 2007-2021 Free Software Foundation, Inc.
+;; Copyright (C) 1999-2021 Free Software Foundation, Inc.
;; Author: Eric M. Ludlam <zappo@gnu.org>
;; Keywords: syntax
((and (featurep 'semantic/db)
(require 'semantic/db-mode)
(semanticdb-minor-mode-p)
- (cl-typep something 'semanticdb-abstract-table))
+ (progn
+ (declare-function semanticdb-abstract-table--eieio-childp
+ "semantic/db")
+ (cl-typep something 'semanticdb-abstract-table)))
(semanticdb-refresh-table something)
(semanticdb-get-tags something))
;; Semanticdb find-results
(setq completion (try-completion pattern collection predicate))
(if (string= pattern completion)
(let ((list (all-completions pattern collection predicate)))
- (setq list (sort list 'string<))
+ (setq list (sort list #'string<))
(if (> (length list) 1)
(with-output-to-temp-buffer "*Completions*"
(display-completion-list
`byte-compile' handler."
(byte-compile-form
(macroexpand-all
- (wisent-automaton-lisp-form (eval form)))))
+ (wisent-automaton-lisp-form (eval form t)))))
(defun wisent-compile-grammar (grammar &optional start-list)
;; This is kept for compatibility with FOO-wy.el files generated
(setq
;; Lexical analysis
semantic-lex-number-expression semantic-java-number-regexp
- semantic-lex-analyzer 'wisent-java-tags-lexer
+ semantic-lex-analyzer #'wisent-java-tags-lexer
;; Parsing
- semantic-tag-expand-function 'semantic-java-expand-tag
+ semantic-tag-expand-function #'semantic-java-expand-tag
;; Environment
- semantic-imenu-summary-function 'semantic-format-tag-prototype
- imenu-create-index-function 'semantic-create-imenu-index
+ semantic-imenu-summary-function #'semantic-format-tag-prototype
+ imenu-create-index-function #'semantic-create-imenu-index
semantic-type-relation-separator-character '(".")
semantic-command-separation-character ";"
;; speedbar and imenu buckets name
(wisent-javascript-jv-wy--install-parser)
(setq
;; Lexical Analysis
- semantic-lex-analyzer 'javascript-lexer-jv
+ semantic-lex-analyzer #'javascript-lexer-jv
semantic-lex-number-expression semantic-java-number-regexp
;; semantic-lex-depth nil ;; Full lexical analysis
;; Parsing
- semantic-tag-expand-function 'wisent-javascript-jv-expand-tag
+ semantic-tag-expand-function #'wisent-javascript-jv-expand-tag
;; Environment
- semantic-imenu-summary-function 'semantic-format-tag-name
- imenu-create-index-function 'semantic-create-imenu-index
+ semantic-imenu-summary-function #'semantic-format-tag-name
+ imenu-create-index-function #'semantic-create-imenu-index
semantic-command-separation-character ";"
))
semantic-type-relation-separator-character '(".")
semantic-command-separation-character ";"
;; Parsing
- semantic-tag-expand-function 'semantic-python-expand-tag
+ semantic-tag-expand-function #'semantic-python-expand-tag
;; Semantic to take over from the one provided by python.
;; The python one, if it uses the senator advice, will hang
;; Emacs unrecoverably.
- imenu-create-index-function 'semantic-create-imenu-index
+ imenu-create-index-function #'semantic-create-imenu-index
;; I need a python guru to update this list:
semantic-symbol->name-assoc-list-for-type-parts '((variable . "Variables")
;;; semantic/wisent/wisent.el --- GNU Bison for Emacs - Runtime -*- lexical-binding: t; -*-
-;;; Copyright (C) 2002-2007, 2009-2021 Free Software Foundation, Inc.
+;; Copyright (C) 2002-2021 Free Software Foundation, Inc.
;; Author: David Ponce <david@dponce.com>
;; Created: 30 January 2002
;;; srecode.el --- Semantic buffer evaluator. -*- lexical-binding: t -*-
-;;; Copyright (C) 2005, 2007-2021 Free Software Foundation, Inc.
+;; Copyright (C) 2005-2021 Free Software Foundation, Inc.
;; Author: Eric M. Ludlam <zappo@gnu.org>
;; Keywords: codegeneration
;; when they make sense. My best bet would be
;; (semantic-tag-function-parent tag), but it is not there, when
;; the function is defined in the scope of a class.
- (let ((member t)
+ (let (;; (member t)
(templates (semantic-tag-get-attribute tag :template))
(modifiers (semantic-tag-modifiers tag)))
;; When the function is a member function, it can have
;; additional modifiers.
- (when member
+ (when t ;; member
;; For member functions, constness is called
;; 'methodconst-flag'.
(if bind
(concat name " (" bind ")")
name)
- `(lambda () (interactive)
- (srecode-insert (concat ,ctxt ":" ,name)))
+ (lambda () (interactive)
+ (srecode-insert (concat ctxt ":" name)))
t)))
- (setcdr ctxtcons (cons
- new
- (cdr ctxtcons)))))
+ (push new (cdr ctxtcons))))
(setq ltab (cdr ltab))))
(setq subtab (cdr subtab)))
(setq
;; Lexical Analysis
- semantic-lex-analyzer 'wisent-srecode-template-lexer
+ semantic-lex-analyzer #'wisent-srecode-template-lexer
;; Parsing
;; Environment
- semantic-imenu-summary-function 'semantic-format-tag-name
- imenu-create-index-function 'semantic-create-imenu-index
+ semantic-imenu-summary-function #'semantic-format-tag-name
+ imenu-create-index-function #'semantic-create-imenu-index
semantic-command-separation-character "\n"
semantic-lex-comment-regex ";;"
;; Speedbar
projects / emacs.git / commitdiff