The other slot will be used to calculate values.
PROJECT-FILE-NAME is a name of project file (short name, like `pom.xml', etc."
(when (and (or (not (slot-boundp this :file))
- (not (oref this :file)))
+ (not (oref this file)))
(slot-boundp this :directory)
- (oref this :directory))
- (oset this :file (expand-file-name project-file-name (oref this :directory))))
+ (oref this directory))
+ (oset this file (expand-file-name project-file-name (oref this directory))))
(when (and (or (not (slot-boundp this :directory))
- (not (oref this :directory)))
+ (not (oref this directory)))
(slot-boundp this :file)
- (oref this :file))
- (oset this :directory (file-name-directory (oref this :file))))
+ (oref this file))
+ (oset this directory (file-name-directory (oref this file))))
)
(setq config nil))
(when (not config)
- (let* ((top (oref proj :directory))
+ (let* ((top (oref proj directory))
(fname (expand-file-name (oref proj config-file-basename) top))
(class (oref proj config-class))
(ignore-type nil))
"Run the current project derived from TARGET in a debugger."
(let* ((proj (ede-target-parent target))
(config (ede-config-get-configuration proj t))
- (debug (oref config :debug-command))
+ (debug (oref config debug-command))
(cmd (read-from-minibuffer
"Debug Command: "
debug))
"Run the current project derived from TARGET."
(let* ((proj (ede-target-parent target))
(config (ede-config-get-configuration proj t))
- (run (concat "./" (oref config :run-command)))
+ (run (concat "./" (oref config run-command)))
(cmd (read-from-minibuffer "Run (like this): " run)))
(ede-shell-run-something target cmd)))
"Compile the entire current project PROJ.
Argument COMMAND is the command to use when compiling."
(let* ((config (ede-config-get-configuration proj t))
- (comp (oref config :build-command)))
+ (comp (oref config build-command)))
(compile comp)))
(cl-defmethod project-compile-target ((obj ede-target-with-config-build) &optional command)
filemap
)
;; Preprocessor files
- (dolist (G (oref config :c-preprocessor-files))
+ (dolist (G (oref config c-preprocessor-files))
(let ((table (semanticdb-file-table-object
(ede-expand-filename root G))))
(when table
(setq filemap (append filemap (oref table lexical-table)))
)))
;; The core table
- (setq filemap (append filemap (oref config :c-preprocessor-table)))
+ (setq filemap (append filemap (oref config c-preprocessor-table)))
filemap
))
(cl-defmethod ede-java-classpath ((proj ede-project-with-config-java))
"Return the classpath for this project."
- (oref (ede-config-get-configuration proj) :classpath))
+ (oref (ede-config-get-configuration proj) classpath))
;; Local variables:
;; generated-autoload-file: "loaddefs.el"
"Make sure the :file is fully expanded."
;; Add ourselves to the master list
(cl-call-next-method)
- (let ((f (expand-file-name (oref this :file))))
+ (let ((f (expand-file-name (oref this file))))
;; Remove any previous entries from the main list.
(let ((old (eieio-instance-tracker-find (file-name-directory f)
:directory 'ede-cpp-root-project-list)))
(file-directory-p f))
(delete-instance this)
(error ":file for ede-cpp-root-project must be a file"))
- (oset this :file f)
- (oset this :directory (file-name-directory f))
+ (oset this file f)
+ (oset this directory (file-name-directory f))
(ede-project-directory-remove-hash (file-name-directory f))
;; NOTE: We must add to global list here because these classes are not
;; created via the typical loader, but instead via calls from a .emacs
(ede-add-project-to-global-list this)
(unless (slot-boundp this 'targets)
- (oset this :targets nil))
+ (oset this targets nil))
))
;;; SUBPROJ Management.
"Compile the entire current project PROJ.
Argument COMMAND is the command to use when compiling."
;; we need to be in the proj root dir for this to work
- (let* ((cmd (oref proj :compile-command))
- (ov (oref proj :local-variables))
+ (let* ((cmd (oref proj compile-command))
+ (ov (oref proj local-variables))
(lcmd (when ov (cdr (assoc 'compile-command ov))))
(cmd-str (cond
((stringp cmd) cmd)
(cl-defmethod project-compile-target ((obj ede-cpp-root-target) &optional command)
"Compile the current target OBJ.
Argument COMMAND is the command to use for compiling the target."
- (when (oref obj :project)
- (project-compile-project (oref obj :project) command)))
+ (when (oref obj project)
+ (project-compile-project (oref obj project) command)))
(cl-defmethod project-rescan ((this ede-cpp-root-project))
"Get the inode of the directory project PROJ is in."
(if (slot-boundp proj 'dirinode)
(oref proj dirinode)
- (oset proj dirinode (ede--inode-for-dir (oref proj :directory)))))
+ (oset proj dirinode (ede--inode-for-dir (oref proj directory)))))
(defun ede--inode-get-toplevel-open-project (inode)
"Return an already open toplevel project that is managing INODE.
(when rootreturn (set rootreturn proj))
;; Find subprojects.
(when (and proj (if ede--disable-inode
- (not (string= ft (expand-file-name (oref proj :directory))))
+ (not (string= ft (expand-file-name
+ (oref proj directory))))
(not (equal inode (ede--project-inode proj)))))
(setq ans (ede-find-subproject-for-directory proj ft)))
ans))
(shortans nil))
(while (and all (not ans))
;; Do the check.
- (let ((pd (expand-file-name (oref (car all) :directory)))
- )
+ (let ((pd (expand-file-name (oref (car all) directory))))
(cond
;; Exact text match.
((string= pd ft)
(setq shortans (car all))
;; We already have a short answer, so see if pd (the match we found)
;; is longer. If it is longer, then it is more precise.
- (when (< (length (oref shortans :directory))
+ (when (< (length (oref shortans directory))
(length pd))
(setq shortans (car all))))
)
(setq shortans (car all))
;; We already have a short answer, so see if pd (the match we found)
;; is longer. If it is longer, then it is more precise.
- (when (< (length (expand-file-name (oref shortans :directory)))
+ (when (< (length (expand-file-name (oref shortans directory)))
(length pd))
(setq shortans (car all))))
)))
proj
(lambda (SP)
(when (not ans)
- (if (string= fulldir (file-truename (oref SP :directory)))
+ (if (string= fulldir (file-truename (oref SP directory)))
(setq ans SP)
(ede-find-subproject-for-directory SP dir)))))
ans)
((and (string= dir default-directory)
ede-object-root-project)
;; Try the local buffer cache first.
- (oref ede-object-root-project :directory))
+ (oref ede-object-root-project directory))
;; See if there is an existing project in DIR.
((setq ans (ede-directory-get-toplevel-open-project dir))
- (oref ans :directory))
+ (oref ans directory))
;; Detect using our file system detector.
((setq ans (ede-detect-directory-for-project dir))
:version ver
:mailinglist (or bug "")
:file fn)))
- (oset ampf :directory (file-name-directory fn))
+ (oset ampf directory (file-name-directory fn))
(oset ampf configureoutputfiles cof)
(make-local-variable 'ede-object)
(setq ede-object ampf)
(mapc (lambda (sp)
(let* ((subdir (file-name-as-directory
(expand-file-name
- sp (file-name-directory (oref this :file)))))
+ sp (file-name-directory (oref this file)))))
(submake (expand-file-name
"Makefile.am"
subdir)))
- (if (string= submake (oref this :file))
+ (if (string= submake (oref this file))
nil ;; don't recurse.. please!
;; For each project id found, see if we need to recycle,
;; and if we do not, then make a new one. Check the deep
(cl-defmethod project-rescan ((this project-am-program))
"Rescan object THIS."
- (oset this :source (makefile-macro-file-list (project-am-macro this)))
- (unless (oref this :source)
- (oset this :source (list (concat (oref this :name) ".c"))))
- (oset this :ldadd (makefile-macro-file-list
- (concat (oref this :name) "_LDADD"))))
+ (oset this source (makefile-macro-file-list (project-am-macro this)))
+ (unless (oref this source)
+ (oset this source (list (concat (oref this name) ".c"))))
+ (oset this ldadd (makefile-macro-file-list
+ (concat (oref this name) "_LDADD"))))
(cl-defmethod project-rescan ((this project-am-lib))
"Rescan object THIS."
- (oset this :source (makefile-macro-file-list (project-am-macro this)))
- (unless (oref this :source)
- (oset this :source (list (concat (file-name-sans-extension (oref this :name)) ".c")))))
+ (oset this source (makefile-macro-file-list (project-am-macro this)))
+ (unless (oref this source)
+ (oset this source (list (concat (file-name-sans-extension
+ (oref this name)) ".c")))))
(cl-defmethod project-rescan ((this project-am-texinfo))
"Rescan object THIS."
- (oset this :include (makefile-macro-file-list (project-am-macro this))))
+ (oset this include (makefile-macro-file-list (project-am-macro this))))
(cl-defmethod project-rescan ((this project-am-man))
"Rescan object THIS."
- (oset this :source (makefile-macro-file-list (project-am-macro this))))
+ (oset this source (makefile-macro-file-list (project-am-macro this))))
(cl-defmethod project-rescan ((this project-am-lisp))
"Rescan the lisp sources."
- (oset this :source (makefile-macro-file-list (project-am-macro this))))
+ (oset this source (makefile-macro-file-list (project-am-macro this))))
(cl-defmethod project-rescan ((this project-am-header))
"Rescan the Header sources for object THIS."
- (oset this :source (makefile-macro-file-list (project-am-macro this))))
+ (oset this source (makefile-macro-file-list (project-am-macro this))))
(cl-defmethod project-rescan ((this project-am-built-src))
"Rescan built sources for object THIS."
- (oset this :source (makefile-macro-file-list "BUILT_SOURCES")))
+ (oset this source (makefile-macro-file-list "BUILT_SOURCES")))
(cl-defmethod project-rescan ((this project-am-extra-dist))
"Rescan object THIS."
- (oset this :source (makefile-macro-file-list "EXTRA_DIST")))
+ (oset this source (makefile-macro-file-list "EXTRA_DIST")))
(cl-defmethod project-am-macro ((this project-am-objectcode))
"Return the default macro to `edit' for this object type."
- (concat (subst-char-in-string ?- ?_ (oref this :name)) "_SOURCES"))
+ (concat (subst-char-in-string ?- ?_ (oref this name)) "_SOURCES"))
(cl-defmethod project-am-macro ((this project-am-header-noinst))
"Return the default macro to `edit' for this object."
(cl-defmethod project-am-macro ((this project-am-texinfo))
"Return the default macro to `edit' for this object type."
- (concat (file-name-sans-extension (oref this :name)) "_TEXINFOS"))
+ (concat (file-name-sans-extension (oref this name)) "_TEXINFOS"))
(cl-defmethod project-am-macro ((this project-am-man))
"Return the default macro to `edit' for this object type."
- (oref this :name))
+ (oref this name))
(cl-defmethod project-am-macro ((this project-am-lisp))
"Return the default macro to `edit' for this object."
(cl-defmethod ede-buffer-mine ((this project-am-makefile) buffer)
"Return t if object THIS lays claim to the file in BUFFER."
(let ((efn (expand-file-name (buffer-file-name buffer))))
- (or (string= (oref this :file) efn)
+ (or (string= (oref this file) efn)
(string-match "/configure\\.ac$" efn)
(string-match "/configure\\.in$" efn)
(string-match "/configure$" efn)
(cl-defmethod ede-buffer-mine ((this project-am-objectcode) buffer)
"Return t if object THIS lays claim to the file in BUFFER."
- (member (file-relative-name (buffer-file-name buffer) (oref this :path))
- (oref this :source)))
+ (member (file-relative-name (buffer-file-name buffer) (oref this path))
+ (oref this source)))
(cl-defmethod ede-buffer-mine ((this project-am-texinfo) buffer)
"Return t if object THIS lays claim to the file in BUFFER."
(let ((bfn (file-relative-name (buffer-file-name buffer)
- (oref this :path))))
- (or (string= (oref this :name) bfn)
- (member bfn (oref this :include)))))
+ (oref this path))))
+ (or (string= (oref this name) bfn)
+ (member bfn (oref this include)))))
(cl-defmethod ede-buffer-mine ((this project-am-man) buffer)
"Return t if object THIS lays claim to the file in BUFFER."
- (string= (oref this :name)
- (file-relative-name (buffer-file-name buffer) (oref this :path))))
+ (string= (oref this name)
+ (file-relative-name (buffer-file-name buffer) (oref this path))))
(cl-defmethod ede-buffer-mine ((this project-am-lisp) buffer)
"Return t if object THIS lays claim to the file in BUFFER."
- (member (file-relative-name (buffer-file-name buffer) (oref this :path))
- (oref this :source)))
+ (member (file-relative-name (buffer-file-name buffer) (oref this path))
+ (oref this source)))
(cl-defmethod project-am-subtree ((ampf project-am-makefile) subdir)
"Return the sub project in AMPF specified by SUBDIR."
(cl-defmethod project-compile-target-command ((this project-am-objectcode))
"Default target to use when compiling an object code target."
- (oref this :name))
+ (oref this name))
(cl-defmethod project-compile-target-command ((this project-am-texinfo))
"Default target t- use when compiling a texinfo file."
- (let ((n (oref this :name)))
+ (let ((n (oref this name)))
(if (string-match "\\.texi?\\(nfo\\)?" n)
(setq n (replace-match ".info" t t n)))
n))
"Get the package information for directory topmost project dir over DIR.
Calculates the info with `project-am-extract-package-info'."
(let ((top (ede-toplevel)))
- (when top (setq dir (oref top :directory)))
+ (when top (setq dir (oref top directory)))
(project-am-extract-package-info dir)))
;; for simple per project include path extension
COMMAND is a text string representing the thing to be run."
(let* ((buff (ede-shell-buffer target))
(cp (ede-target-parent target))
- (dd (oref cp :directory)))
+ (dd (oref cp directory)))
;; Show the new buffer.
(when (not (get-buffer-window buff))
(switch-to-buffer-other-window buff t))
v nil v))))
(let ((ede-object (ede-toplevel)))
;; Don't update anything if there was no change.
- (unless (string= (oref ede-object :version) newversion)
- (oset ede-object :version newversion)
+ (unless (string= (oref ede-object version) newversion)
+ (oset ede-object version newversion)
(project-update-version ede-object)
(ede-update-version-in-source ede-object newversion))))
(cl-defmethod semantic-analyze-interesting-tag
((context semantic-analyze-context))
"Return a tag from CONTEXT that would be most interesting to a user."
- (let ((prefix (reverse (oref context :prefix))))
+ (let ((prefix (reverse (oref context prefix))))
;; Go back through the prefix until we find a tag we can return.
(while (and prefix (not (semantic-tag-p (car prefix))))
(setq prefix (cdr prefix)))
(cl-defmethod semantic-analyze-interesting-tag
((context semantic-analyze-context-functionarg))
"Try the base, and if that fails, return what we are assigning into."
- (or (cl-call-next-method) (car-safe (oref context :function))))
+ (or (cl-call-next-method) (car-safe (oref context function))))
(cl-defmethod semantic-analyze-interesting-tag
((context semantic-analyze-context-assignment))
"Try the base, and if that fails, return what we are assigning into."
- (or (cl-call-next-method) (car-safe (oref context :assignee))))
+ (or (cl-call-next-method) (car-safe (oref context assignee))))
;;; ANALYSIS
;;
(cl-defmethod semantic-analyze-pulse ((context semantic-analyze-context))
"Pulse the region that CONTEXT affects."
(require 'pulse)
- (with-current-buffer (oref context :buffer)
- (let ((bounds (oref context :bounds)))
+ (with-current-buffer (oref context buffer)
+ (let ((bounds (oref context bounds)))
(when bounds
(pulse-momentary-highlight-region (car bounds) (cdr bounds))))))
(defun semantic-analyzer-debug-describe-scope (ctxt &optional classconstraint)
"Describe the scope in CTXT for finding a global symbol.
Optional argument CLASSCONSTRAINT says to output to tags of that class."
- (let* ((scope (oref ctxt :scope))
+ (let* ((scope (oref ctxt scope))
(parents (oref scope parents))
(cc (or classconstraint (oref ctxt prefixclass)))
)
"Return the implementations derived in the reference analyzer REFS.
Optional argument IN-BUFFER indicates that the returned tag should be in an active buffer."
(let ((allhits (oref refs rawsearchdata))
- (tag (oref refs :tag))
+ (tag (oref refs tag))
(impl nil)
)
(semanticdb-find-result-mapc
"Return the prototypes derived in the reference analyzer REFS.
Optional argument IN-BUFFER indicates that the returned tag should be in an active buffer."
(let ((allhits (oref refs rawsearchdata))
- (tag (oref refs :tag))
+ (tag (oref refs tag))
(proto nil))
(semanticdb-find-result-mapc
(lambda (T DB)
(require 'semantic/analyze/complete)
(with-current-buffer (oref context buffer)
(let* ((normal (semantic-analyze-possible-completions-default context))
- (classes (oref context :prefixclass))
+ (classes (oref context prefixclass))
(filetags nil))
(when (memq 'filename classes)
- (let* ((prefix (car (oref context :prefix)))
+ (let* ((prefix (car (oref context prefix)))
(completetext (cond ((semantic-tag-p prefix)
(semantic-tag-name prefix))
((stringp prefix)
(localstuff (oref scope scope)))
(list
(cons
- (oref scope :table)
+ (oref scope table)
(semantic-find-tags-for-completion prefix localstuff)))))
;(semanticdb-brute-deep-find-tags-for-completion prefix (oref obj path))))
(stream nil)
)
(dolist (table (semanticdb-get-database-tables db))
- (when (eq lmode (oref table :major-mode))
+ (when (eq lmode (oref table major-mode))
(setq stream
(semanticdb-typecache-merge-streams
stream
(cl-defmethod semantic-debug-highlight-lexical-token ((iface semantic-debug-interface) token)
"For IFACE, highlight TOKEN in the source buffer .
TOKEN is a lexical token."
- (set-buffer (oref iface :source-buffer))
+ (set-buffer (oref iface source-buffer))
(object-add-to-list iface 'overlays
(semantic-lex-highlight-token token))
NONTERM is the name of the rule currently being processed that shows up
as a nonterminal (or tag) in the source buffer.
If RULE and MATCH indices are specified, highlight those also."
- (set-buffer (oref iface :parser-buffer))
+ (set-buffer (oref iface parser-buffer))
(let* ((rules (semantic-find-tags-by-class 'nonterminal (current-buffer)))
(nt (semantic-find-first-tag-by-name nonterm rules))
;; Get the semanticdb statement, and display it's contents.
(princ "\nDetails for header file...\n")
(princ "\nMajor Mode: ")
- (princ (oref table :major-mode))
+ (princ (oref table major-mode))
(princ "\nTags: ")
- (princ (format "%s entries" (length (oref table :tags))))
+ (princ (format "%s entries" (length (oref table tags))))
(princ "\nFile Size: ")
- (princ (format "%s chars" (oref table :pointmax)))
+ (princ (format "%s chars" (oref table pointmax)))
(princ "\nSave State: ")
(cond ((oref table dirty)
(princ "Table needs to be saved."))
(with-mode-local emacs-lisp-mode
(semantic-analyze-possible-completions context))
(with-current-buffer (oref context buffer)
- (let* ((prefix (car (oref context :prefix)))
+ (let* ((prefix (car (oref context prefix)))
(completetext (cond ((semantic-tag-p prefix)
(semantic-tag-name prefix))
((stringp prefix)
(al nil))
(while (< idx len)
(let ((r (ring-ref ring idx)))
- (setq al (cons (cons (oref r :object-name) r)
+ (setq al (cons (cons (oref r object-name) r)
al)))
(setq idx (1+ idx)))
(nreverse al)))
default-directory))
;; CScope has to be run from the project root where
;; cscope.out is.
- (b (cedet-cscope-search (oref tool :searchfor)
- (oref tool :searchtype)
- (oref tool :resulttype)
- (oref tool :searchscope)
- ))
- )
- (semantic-symref-parse-tool-output tool b)
- ))
+ (b (cedet-cscope-search (oref tool searchfor)
+ (oref tool searchtype)
+ (oref tool resulttype)
+ (oref tool searchscope))))
+ (semantic-symref-parse-tool-output tool b)))
(defconst semantic-symref-cscope--line-re
"^\\([^ ]+\\) [^ ]+ \\([0-9]+\\) ")
(cl-defmethod semantic-symref-parse-tool-output-one-line ((tool semantic-symref-tool-cscope))
"Parse one line of grep output, and return it as a match list.
Moves cursor to end of the match."
- (cond ((eq (oref tool :resulttype) 'file)
+ (cond ((eq (oref tool resulttype) 'file)
;; Search for files
(when (re-search-forward "^\\([^\n]+\\)$" nil t)
(match-string 1)))
- ((eq (oref tool :searchtype) 'tagcompletions)
+ ((eq (oref tool searchtype) 'tagcompletions)
;; Search for files
(when (re-search-forward "^[^ ]+ [^ ]+ [^ ]+ \\(.*\\)$" nil t)
(let ((subtxt (match-string 1))
- (searchtxt (oref tool :searchfor)))
+ (searchtxt (oref tool searchfor)))
(if (string-match (concat "\\<" searchtxt "\\(\\w\\|\\s_\\)*\\>")
subtxt)
(match-string 0 subtxt)
;; We have to return something at this point.
subtxt)))
)
- ((eq (oref tool :resulttype) 'line-and-text)
+ ((eq (oref tool resulttype) 'line-and-text)
(when (re-search-forward semantic-symref-cscope--line-re nil t)
(list (string-to-number (match-string 2))
(expand-file-name (match-string 1))
(cl-defmethod semantic-symref-perform-search ((tool semantic-symref-tool-global))
"Perform a search with GNU Global."
- (let ((b (cedet-gnu-global-search (oref tool :searchfor)
- (oref tool :searchtype)
- (oref tool :resulttype)
- (oref tool :searchscope)
- ))
- )
- (semantic-symref-parse-tool-output tool b)
- ))
+ (let ((b (cedet-gnu-global-search (oref tool searchfor)
+ (oref tool searchtype)
+ (oref tool resulttype)
+ (oref tool searchscope))))
+ (semantic-symref-parse-tool-output tool b)))
(defconst semantic-symref-global--line-re
"^\\([^ ]+\\) +\\([0-9]+\\) \\([^ ]+\\) ")
(cl-defmethod semantic-symref-parse-tool-output-one-line ((tool semantic-symref-tool-global))
"Parse one line of grep output, and return it as a match list.
Moves cursor to end of the match."
- (cond ((or (eq (oref tool :resulttype) 'file)
- (eq (oref tool :searchtype) 'tagcompletions))
+ (cond ((or (eq (oref tool resulttype) 'file)
+ (eq (oref tool searchtype) 'tagcompletions))
;; Search for files
(when (re-search-forward "^\\([^\n]+\\)$" nil t)
(match-string 1)))
- ((eq (oref tool :resulttype) 'line-and-text)
+ ((eq (oref tool resulttype) 'line-and-text)
(when (re-search-forward semantic-symref-global--line-re nil t)
(list (string-to-number (match-string 2))
(match-string 3)
(cl-defmethod semantic-symref-perform-search ((tool semantic-symref-tool-idutils))
"Perform a search with IDUtils."
- (let ((b (cedet-idutils-search (oref tool :searchfor)
- (oref tool :searchtype)
- (oref tool :resulttype)
- (oref tool :searchscope)
- ))
- )
- (semantic-symref-parse-tool-output tool b)
- ))
+ (let ((b (cedet-idutils-search (oref tool searchfor)
+ (oref tool searchtype)
+ (oref tool resulttype)
+ (oref tool searchscope))))
+ (semantic-symref-parse-tool-output tool b)))
(defconst semantic-symref-idutils--line-re
"^\\(\\(?:[a-zA-Z]:\\)?[^:\n]+\\):\\([0-9]+\\):")
(cl-defmethod semantic-symref-parse-tool-output-one-line ((tool semantic-symref-tool-idutils))
"Parse one line of grep output, and return it as a match list.
Moves cursor to end of the match."
- (cond ((eq (oref tool :resulttype) 'file)
+ (cond ((eq (oref tool resulttype) 'file)
;; Search for files
(when (re-search-forward "^\\([^\n]+\\)$" nil t)
(match-string 1)))
- ((eq (oref tool :searchtype) 'tagcompletions)
+ ((eq (oref tool searchtype) 'tagcompletions)
(when (re-search-forward "^\\([^ ]+\\) " nil t)
(match-string 1)))
- ((eq (oref tool :resulttype) 'line-and-text)
+ ((eq (oref tool resulttype) 'line-and-text)
(when (re-search-forward semantic-symref-idutils--line-re nil t)
(list (string-to-number (match-string 2))
(expand-file-name (match-string 1) default-directory)
(erase-buffer)
;; Insert the contents.
(let ((lastfile nil))
- (dolist (T (oref results :hit-tags))
+ (dolist (T (oref results hit-tags))
(unless (equal lastfile (semantic-tag-file-name T))
(setq lastfile (semantic-tag-file-name T))
(insert-button lastfile
{kmacro-end-macro} to end the macro, and return to the symbol found list."
(interactive)
(let* ((oldsym (oref (oref semantic-symref-current-results
- :created-by)
- :searchfor))
+ created-by)
+ searchfor))
(ol (save-excursion
(end-of-line)
(car (semantic-overlays-at (1- (point))))))
(interactive
(list (read-string "Rename to: "
(oref (oref semantic-symref-current-results
- :created-by)
- :searchfor))))
+ created-by)
+ searchfor))))
(let ((count (semantic-symref-list-map-open-hits
(lambda () (replace-match newname nil t)))))
(semantic-symref-list-update-open-hits)
;; class members. (Not Done)
(let ((oldsym (oref (oref semantic-symref-current-results
- :created-by)
- :searchfor))
+ created-by)
+ searchfor))
(count 0))
(save-excursion
(goto-char (point-min))
useful. Instead, look at the current symbol. If it is a command
do primitive texinfo built ins. If not, use ispell to lookup words
that start with that symbol."
- (let ((prefix (car (oref context :prefix)))
+ (let ((prefix (car (oref context prefix)))
)
- (cond ((member 'function (oref context :prefixclass))
+ (cond ((member 'function (oref context prefixclass))
;; Do completion for texinfo commands
(let* ((cmd (substring prefix 1))
(lst (all-completions
(mapcar (lambda (f) (semantic-tag (concat "@" f) 'function))
lst))
)
- ((member 'word (oref context :prefixclass))
+ ((member 'word (oref context prefixclass))
;; Do completion for words via ispell.
(require 'ispell)
(let ((word-list (ispell-lookup-words prefix)))
(srecode-dictionary-set-value dict "PROJECT_FILENAME" relfname)
(srecode-dictionary-set-value dict "PROJECT_DIRECTORY" reldir)
(srecode-dictionary-set-value dict "PROJECT_NAME" (ede-name (ede-toplevel)))
- (srecode-dictionary-set-value dict "PROJECT_VERSION" (oref (ede-toplevel) :version))
- )
+ (srecode-dictionary-set-value dict "PROJECT_VERSION"
+ (oref (ede-toplevel) version)))
;; If there is no EDE project, then put in some base values.
(srecode-dictionary-set-value dict "PROJECT_FILENAME" bfn)
(srecode-dictionary-set-value dict "PROJECT_DIRECTORY" dir)
(while lp
- (let* ((objname (oref (car lp) :object-name))
- (context (oref (car lp) :context))
+ (let* ((objname (oref (car lp) object-name))
+ (context (oref (car lp) context))
(globalname (concat context ":" objname))
)
(tmpl (oref table templates)))
;; Loop over all the templates, and xref.
(while tmpl
- (oset (car tmpl) :table table)
+ (oset (car tmpl) table table)
(setq tmpl (cdr tmpl))))
))
"Dump the state of the SRecode template inserter INS."
(princ "INS: \"")
(princ (eieio-object-name-string ins))
- (when (oref ins :secondname)
+ (when (oref ins secondname)
(princ "\" : \"")
- (princ (oref ins :secondname)))
+ (princ (oref ins secondname)))
(princ "\" type \"")
(let* ((oc (symbol-name (eieio-object-class ins)))
(junk (string-match "srecode-template-inserter-" oc))
(srecode-semantic-apply-tag-to-dict-default tag-wrapper dict)
;; Pull out the tag for the individual pieces.
- (let* ((tag (oref tag-wrapper :prime))
+ (let* ((tag (oref tag-wrapper prime))
(class (semantic-tag-class tag)))
;; Add additional information based on the class of the tag.
(cl-call-next-method this (nreverse newfields))
(when (not (slot-boundp this 'compiled))
- (let ((val (oref this :value))
+ (let ((val (oref this value))
(comp nil))
(while val
(let ((nval (car val))
(error "Don't know how to handle variable value %S" nval)))
)
(setq val (cdr val)))
- (oset this :compiled (nreverse comp))))))
+ (oset this compiled (nreverse comp))))))
;;; DICTIONARY METHODS
;;
;; Tables are sorted with highest priority first, useful for looking
;; up templates, but this means we need to install the variables in
;; reverse order so higher priority variables override lower ones.
- (let ((tabs (reverse (oref tpl :tables))))
+ (let ((tabs (reverse (oref tpl tables))))
(require 'srecode/find) ; For srecode-template-table-in-project-p
(while tabs
(when (srecode-template-table-in-project-p (car tabs))
(let* ((dv (oref cp defaultvalue))
(sti (oref cp firstinserter))
(start (point))
- (name (oref sti :object-name)))
+ (name (oref sti object-name)))
(cond
;; No default value.
(srecode-semantic-apply-tag-to-dict-default tagobj dict)
;; Pull out the tag for the individual pieces.
- (let* ((tag (oref tagobj :prime))
+ (let* ((tag (oref tagobj prime))
(doc (semantic-tag-docstring tag)))
;; It is much more common to have doc on ELisp.
Return t if something was extracted.
Return nil if this inserter doesn't need to extract anything."
(srecode-dictionary-set-value vdict
- (oref ins :object-name)
+ (oref ins object-name)
(buffer-substring-no-properties
- start end)
- )
+ start end))
t)
;;; Section Inserter
"Extract text from START/END and store in INDICT.
Return the starting location of the first plain-text match.
Return nil if nothing was extracted."
- (let ((name (oref ins :object-name))
+ (let ((name (oref ins object-name))
(subdict (srecode-create-dictionary indict))
- (allsubdict nil)
- )
+ (allsubdict nil))
;; Keep extracting till we can extract no more.
(while (condition-case nil
;; There are two modes for includes. One is with no dict,
;; so it is inserted straight. If the dict has a name, then
;; we need to run once per dictionary occurrence.
- (if (not (string= (oref ins :object-name) ""))
+ (if (not (string= (oref ins object-name) ""))
;; With a name, do the insertion.
(let ((subdict (srecode-dictionary-add-section-dictionary
- dict (oref ins :object-name))))
+ dict (oref ins object-name))))
(error "Need to implement include w/ name extractor")
;; Recurse into the new template while no errors.
(while (condition-case nil
"Return non-nil if the table TAB can be used in the current project.
If TAB has a :project set, check that the directories match.
If TAB is nil, then always return t."
- (let ((proj (oref tab :project)))
+ (let ((proj (oref tab project)))
;; Return t if the project wasn't set.
(if (not proj) t
;; If the project directory was set, let's check it.
belonging to a specific application. If APPLICATION is nil, then only
tables that do not belong to an application will be searched."
(let* ((mt tab)
- (tabs (oref mt :tables))
+ (tabs (oref mt tables))
(ans nil))
(while (and (not ans) tabs)
- (let ((app (oref (car tabs) :application)))
+ (let ((app (oref (car tabs) application)))
(when (or (and (not application) (null app))
(and application (eq app application)))
(setq ans (srecode-template-get-table (car tabs) template-name
(setq tabs (cdr tabs))))
(or ans
;; Recurse to the default.
- (when (not (equal (oref tab :major-mode) 'default))
+ (when (not (equal (oref tab major-mode) 'default))
(srecode-template-get-table (srecode-get-mode-table 'default)
template-name context application)))))
belonging to a specific application. If APPLICATION is nil, then only
tables that do not belong to an application will be searched."
(let* ((mt tab)
- (tabs (oref mt :tables))
+ (tabs (oref mt tables))
(ans nil))
(while (and (not ans) tabs)
- (let ((app (oref (car tabs) :application)))
+ (let ((app (oref (car tabs) application)))
(when (or (and (not application) (null app))
(and application (eq app application)))
(setq ans (srecode-template-get-table-for-binding
(setq tabs (cdr tabs))))
(or ans
;; Recurse to the default.
- (when (not (equal (oref tab :major-mode) 'default))
+ (when (not (equal (oref tab major-mode) 'default))
(srecode-template-get-table-for-binding
(srecode-get-mode-table 'default) binding context)))))
;;; Interactive
;; Load up the hash table for our current mode.
(let* ((mt (srecode-get-mode-table mmode))
- (tabs (when mt (oref mt :tables))))
+ (tabs (when mt (oref mt tables))))
(dolist (tab tabs)
;; Exclude templates for a particular application.
- (when (and (not (oref tab :application))
+ (when (and (not (oref tab application))
(srecode-template-table-in-project-p tab))
(maphash (lambda (key temp)
(when (or (not predicate)
dictionary)
"Insert the STI inserter."
;; Convert the name into a name/fcn pair
- (let* ((name (oref sti :object-name))
- (fcnpart (oref sti :secondname))
+ (let* ((name (oref sti object-name))
+ (fcnpart (oref sti secondname))
(val (srecode-dictionary-lookup-name
dictionary name))
- (do-princ t)
- )
+ (do-princ t))
;; Alert if a macro wasn't found.
(when (not val)
(message "Warning: macro %S was not found in the dictionary." name)
)
(while prompts
(when (string= (semantic-tag-name (car prompts))
- (oref ins :object-name))
- (oset ins :prompt
+ (oref ins object-name))
+ (oset ins prompt
(semantic-tag-get-attribute (car prompts) :text))
- (oset ins :defaultfcn
+ (oset ins defaultfcn
(semantic-tag-get-attribute (car prompts) :default))
- (oset ins :read-fcn
+ (oset ins read-fcn
(or (semantic-tag-get-attribute (car prompts) :read)
'read-string))
)
dictionary)
"Insert the STI inserter."
(let ((val (srecode-dictionary-lookup-name
- dictionary (oref sti :object-name))))
+ dictionary (oref sti object-name))))
(if val
;; Does some extra work. Oh well.
(cl-call-next-method)
;; the user can use the same name again later.
(srecode-dictionary-set-value
(srecode-root-dictionary dictionary)
- (oref sti :object-name) val)
+ (oref sti object-name) val)
;; Now that this value is safely stowed in the dictionary,
;; we can do what regular inserters do.
dictionary)
"Derive the default value for an askable inserter STI.
DICTIONARY is used to derive some values."
- (let ((defaultfcn (oref sti :defaultfcn)))
+ (let ((defaultfcn (oref sti defaultfcn)))
(cond
((stringp defaultfcn)
defaultfcn)
Use DICTIONARY to resolve values."
(let* ((prompt (oref sti prompt))
(default (srecode-insert-ask-default sti dictionary))
- (reader (oref sti :read-fcn))
+ (reader (oref sti read-fcn))
(val nil)
)
(cond ((eq reader 'y-or-n-p)
(if (y-or-n-p (or prompt
(format "%s? "
- (oref sti :object-name))))
+ (oref sti object-name))))
(setq val default)
(setq val "")))
((eq reader 'read-char)
"%c"
(read-char (or prompt
(format "Char for %s: "
- (oref sti :object-name))))))
+ (oref sti object-name))))))
)
(t
(save-excursion
(setq val (funcall reader
(or prompt
(format "Specify %s: "
- (oref sti :object-name)))
+ (oref sti object-name)))
default
)))))
;; Return our derived value.
Use DICTIONARY to resolve values."
(let* ((default (srecode-insert-ask-default sti dictionary))
(compound-value
- (srecode-field-value (oref sti :object-name)
+ (srecode-field-value (oref sti object-name)
:firstinserter sti
:defaultvalue default))
)
Loops over the embedded CODE which was saved here during compilation.
The template to insert is stored in SLOT."
(let ((dicts (srecode-dictionary-lookup-name
- dictionary (oref sti :object-name))))
+ dictionary (oref sti object-name))))
(when (not (listp dicts))
(srecode-insert-report-error
dictionary
"Cannot insert section %S from non-section variable."
- (oref sti :object-name)))
+ (oref sti object-name)))
;; If there is no section dictionary, then don't output anything
;; from this section.
(while dicts
(srecode-insert-report-error
dictionary
"Cannot insert section %S from non-section variable."
- (oref sti :object-name)))
+ (oref sti object-name)))
(srecode-insert-subtemplate sti (car dicts) slot)
(setq dicts (cdr dicts)))))
Shorten input until the END token is found.
Return the remains of INPUT."
(let* ((out (srecode-compile-split-code tag input STATE
- (oref ins :object-name))))
+ (oref ins object-name))))
(oset ins template (srecode-template
(eieio-object-name-string ins)
:context nil
(cl-defmethod srecode-match-end ((ins srecode-template-inserter-section-end) name)
"For the template inserter INS, do I end a section called NAME?"
- (string= name (oref ins :object-name)))
+ (string= name (oref ins object-name)))
(defclass srecode-template-inserter-include (srecode-template-inserter-subtemplate)
((key :initform ?>
"For the template inserter STI, lookup the template to include.
Finds the template with this macro function part and stores it in
this template instance."
- (let ((templatenamepart (oref sti :secondname)))
+ (let ((templatenamepart (oref sti secondname)))
;; If there was no template name, throw an error.
(unless templatenamepart
(srecode-insert-report-error
dictionary
"Include macro `%s' needs a template name"
- (oref sti :object-name)))
+ (oref sti object-name)))
;; NOTE: We used to cache the template and not look it up a second time,
;; but changes in the template tables can change which template is
)
;; Store the found template into this object for later use.
- (oset sti :includedtemplate tmpl))
+ (oset sti includedtemplate tmpl))
(unless (oref sti includedtemplate)
;; @todo - Call into a debugger to help find the template in question.
(srecode-insert-report-error
dictionary
"No template \"%s\" found for include macro `%s'"
- templatenamepart (oref sti :object-name)))))
+ templatenamepart (oref sti object-name)))))
(cl-defmethod srecode-insert-method ((sti srecode-template-inserter-include)
dictionary)
(srecode-insert-include-lookup sti dictionary)
;; Insert the template.
;; Our baseclass has a simple way to do this.
- (if (srecode-dictionary-lookup-name dictionary (oref sti :object-name))
+ (if (srecode-dictionary-lookup-name dictionary (oref sti object-name))
;; If we have a value, then call the next method
(srecode-insert-method-helper sti dictionary 'includedtemplate)
;; If we don't have a special dictionary, then just insert with the
(lambda (dict)
(let ((srecode-template-inserter-point-override nil))
(if (srecode-dictionary-lookup-name
- dict (oref sti :object-name))
+ dict (oref sti object-name))
;; Insert our sectional part with looping.
(srecode-insert-method-helper
sti dict 'template)
;;(srecode-load-tables-for-mode major-mode)
(let* ((modetable (srecode-get-mode-table major-mode))
- (subtab (when modetable (oref modetable :tables)))
+ (subtab (when modetable (oref modetable tables)))
(context nil)
(active nil)
(ltab nil)
(if (not temp)
(error "No Template named %s" template-name))
;; We need a template specific table, since tables chain.
- (let ((tab (oref temp :table))
+ (let ((tab (oref temp table))
(names nil)
)
- (find-file (oref tab :file))
- (setq names (semantic-find-tags-by-name (oref temp :object-name)
+ (find-file (oref tab file))
+ (setq names (semantic-find-tags-by-name (oref temp object-name)
(current-buffer)))
(cond ((= (length names) 1)
(semantic-go-to-tag (car names))
(semantic-momentary-highlight-tag (car names)))
((> (length names) 1)
- (let* ((ctxt (semantic-find-tags-by-name (oref temp :context)
+ (let* ((ctxt (semantic-find-tags-by-name (oref temp context)
(current-buffer)))
(cls (semantic-find-tags-by-class 'context ctxt))
)
aspect of the compound value."
(if (not function)
;; Just format it in some handy dandy way.
- (semantic-format-tag-prototype (oref cp :prime))
+ (semantic-format-tag-prototype (oref cp prime))
;; Otherwise, apply the function to the tag itself.
- (funcall function (oref cp :prime))
- ))
+ (funcall function (oref cp prime))))
\f
;;; Managing the `current' tag
(srecode-dictionary-set-value dict "TAG" tagobj)
;; Pull out the tag for the individual pieces.
- (let ((tag (oref tagobj :prime)))
+ (let ((tag (oref tagobj prime)))
(srecode-dictionary-set-value dict "NAME" (semantic-tag-name tag))
(srecode-dictionary-set-value dict "TYPE" (semantic-format-tag-type tag nil))
)
(when inserter
(let ((base
- (cons (oref inserter :object-name)
+ (cons (oref inserter object-name)
(if (and (slot-boundp inserter :secondname)
- (oref inserter :secondname))
- (split-string (oref inserter :secondname)
+ (oref inserter secondname))
+ (split-string (oref inserter secondname)
":")
nil)))
(key (oref inserter key)))
srecode-template-mode (context)
"Return a list of possible completions based on NONTEXT."
(with-current-buffer (oref context buffer)
- (let* ((prefix (car (last (oref context :prefix))))
+ (let* ((prefix (car (last (oref context prefix))))
(prefixstr (cond ((stringp prefix)
prefix)
((semantic-tag-p prefix)
; prefix)
; ((stringp (car prefix))
; (car prefix))))
- (argtype (car (oref context :argument)))
+ (argtype (car (oref context argument)))
(matches nil))
;; Depending on what the analyzer is, we have different ways
;; into the search table first, allowing lower priority items
;; to be the items found in the search table.
(object-sort-list mt 'modetables (lambda (a b)
- (> (oref a :priority)
- (oref b :priority))))
+ (> (oref a priority)
+ (oref b priority))))
;; Return it.
new))
(cl-defmethod srecode-dump ((tab srecode-mode-table))
"Dump the contents of the SRecode mode table TAB."
(princ "MODE TABLE FOR ")
- (princ (oref tab :major-mode))
+ (princ (oref tab major-mode))
(princ "\n--------------------------------------------\n\nNumber of tables: ")
- (let ((subtab (oref tab :tables)))
+ (let ((subtab (oref tab tables)))
(princ (length subtab))
(princ "\n\n")
(while subtab
(princ "Template Table for ")
(princ (eieio-object-name-string tab))
(princ "\nPriority: ")
- (prin1 (oref tab :priority))
- (when (oref tab :application)
+ (prin1 (oref tab priority))
+ (when (oref tab application)
(princ "\nApplication: ")
- (princ (oref tab :application)))
- (when (oref tab :framework)
+ (princ (oref tab application)))
+ (when (oref tab framework)
(princ "\nFramework: ")
- (princ (oref tab :framework)))
- (when (oref tab :project)
+ (princ (oref tab framework)))
+ (when (oref tab project)
(require 'srecode/find) ; For srecode-template-table-in-project-p
(princ "\nProject Directory: ")
- (princ (oref tab :project))
+ (princ (oref tab project))
(when (not (srecode-template-table-in-project-p tab))
(princ "\n ** Not Usable in this file. **")))
(princ "\n\nVariables:\n")
(error "No tag to insert for :texitag template argument"))
;; Extract the tag out of the compound object.
- (setq tag (oref tag :prime))
+ (setq tag (oref tag prime))
;; Extract the doc string
(setq doc (semantic-documentation-for-tag tag))
projects / emacs.git / commitdiff